Ecole Nationale Supérieure d’Informatique et

d’Analyse des Systèmes - RABAT

lung-cancer-detection system:
Real time detection using CNN and FPGA

Encadré par :

Mr.Thierry Bertin
Created by :

Mohammed El Kasri
Membres de jury :

Pr.Taoufik Rachad
Année Scolaire 2022/2023
Acknowledgements

I would like to express my sincere gratitude to all those who contributed to the successful comple-
tion of my internship project on building a CNN lung cancer detection model and implementing it
in FPGA using Xilinx. This endeavor would not have been possible without the support, guidance,
and collaboration of numerous individuals and organizations.
would like to extend my heartfelt thanks to my internship supervisor, Thierry Bertin, for
their unwavering support and mentorship throughout this internship. Their expertise, patience,
and encouragement played a pivotal role in shaping this project and my understanding of AI in
healthcare and FPGA development.
I am immensely grateful to the entire team at SMART FACTORY, who welcomed me warmly
into their workspace and provided a nurturing environment for learning and growth. The col-
laborative spirit and dedication of my colleagues were instrumental in overcoming challenges and
achieving project milestones.
I extend my appreciation to the healthcare professionals who provided valuable insights into
the clinical aspects of lung cancer detection. Their expertise and willingness to share knowledge
enriched the project’s context and relevance.
I would like to acknowledge the contributions of my fellow interns and classmates who engaged
in stimulating discussions and brainstorming sessions, further enhancing the project’s creativity
and innovation.
I owe a debt of gratitude to the creators of open-source tools, libraries, and frameworks that
facilitated the development and implementation of the CNN model and FPGA design. Their
dedication to advancing technology for the greater good is commendable.
I would also like to thank my friends and family for their unwavering support, understanding,
and encouragement throughout my internship journey. Their belief in my abilities has been a
constant source of motivation.
Lastly, I express my gratitude to the academic institution, ENSIAS, for affording me the
opportunity to undertake this internship and apply my knowledge to real-world challenges.
This internship has been a transformative experience, and the contributions of each individual
and entity mentioned above have played an integral role in its success. I look forward to continuing
my journey of exploration and innovation in the fields of AI and FPGA development, building upon
the foundation laid during this internship.

1
Abstract

Lung cancer is a global health concern, with early detection playing a pivotal role in improving pa-
tient outcomes. This internship report documents the journey of building a Convolutional Neural
Network (CNN) for lung cancer detection and its subsequent implementation on an FPGA using
Xilinx tools. The project aimed to leverage the power of deep learning for accurate diagnosis and
the efficiency of FPGA hardware for real-time inference.

The internship commenced with the collection and preprocessing of a carefully curated dataset
of chest X-ray images. This dataset formed the foundation for training and evaluating the CNN
model, which was meticulously designed to identify lung abnormalities. The model’s architecture,
training process, and evaluation metrics were thoroughly discussed and presented.

One of the significant achievements of this project was the successful implementation of the
CNN model on an FPGA, demonstrating the potential for real-time inference in medical applica-
tions. The FPGA design process, including hardware description and optimization strategies, was
documented to provide insights into the intricacies of hardware acceleration.

Results showcased the CNN model’s capability to detect lung abnormalities with high accu-
racy, precision, and recall. Furthermore, interpretability techniques, such as saliency maps and
visualizations, provided valuable insights into the model’s decision-making process, enhancing its
transparency and clinical relevance.

Ethical considerations were paramount throughout the project, addressing patient data privacy
and model fairness. The report underscores the ethical responsibilities associated with deploying
AI in healthcare and underscores the need for responsible AI practices.

In conclusion, this internship project represents a significant step forward in the intersection
of deep learning and FPGA-based AI for medical applications. The report not only summarizes
the technical aspects of model development and FPGA implementation but also highlights the
potential impact of this technology on early lung cancer detection. The internship experience
has provided invaluable insights into the fields of medical image analysis, AI ethics, and FPGA
development, setting the stage for continued exploration and innovation in the healthcare domain.

2
Table Of Contents

1 Introduction 5
1.1 General Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 3d smart factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1.1 Our Mission: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Literature Review 9
2.1 Lung Cancer Detection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 AI in Healthcare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 FPGA-Based AI Acceleration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 Integration of AI and FPGA in Healthcare . . . . . . . . . . . . . . . . . . . . . . . 10

3 CNN Model 14
3.1 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 Model development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.1 Data Visualization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2.2 Data preparation for training . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.2.1 HotEncoding: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.3 Model Development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.4 Tensorflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2.4.1 Model Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.4.2 Callback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2.4.3 Model training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2.5 Model Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4 FPGA Implementation 32
4.1 General overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.1.1 Mapping the CNN Model: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.1.2 FPGA Toolchain: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.1.2.1 VHDL Implementation of a Feedforward Neural Network Layer . . 35
4.2 Implementation of a neural network model that detects lung cancer images on FPGA 36
4.3 Presentation of the Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3.2 Importing Dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4 Network Topology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

1
 4.4.1 Network Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4.2 Activation Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.4.3 Training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.4.3.1 Training Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.4.4 Prediction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.4.5 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.4.6 Saving Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.5 Data Representation and Network Parameters . . . . . . . . . . . . . . . . . . . . . 41
4.5.1 Fixed-Point Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.5.2 Floating-Point Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.5.2.1 Components of Floating-Point Format . . . . . . . . . . . . . . . . 42
4.5.2.2 IEEE 754 Floating-Point Formats . . . . . . . . . . . . . . . . . . . 42
4.5.3 Converting from Floating-Point to Fixed-Point in FPGA . . . . . . . . . . . 43
4.5.3.1 Resource Efficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.5.3.2 Deterministic Behavior . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.5.3.3 Real-Time Processing . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.5.3.4 Reduced Data Transfer Overheads . . . . . . . . . . . . . . . . . . 44
4.5.3.5 Precision Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.5.3.6 Conversion Considerations . . . . . . . . . . . . . . . . . . . . . . . 44
4.6 Mathematical Modeling of the Neural Network . . . . . . . . . . . . . . . . . . . . . 44
4.6.1 Neural Network Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.6.2 Output Calculation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.6.3 Weights from Hidden Neurons to Output Neuron . . . . . . . . . . . . . . . 46
4.6.4 Forward Propagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.6.5 Back Propagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.7 Network Training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.7.1 Supervised Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.7.2 Training with Octave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.7.2.1 GNU Octave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.7.2.2 Training Process Details . . . . . . . . . . . . . . . . . . . . . . . . 48
4.8 Implementation in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.8.1 Network Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.8.2 Hardware Description of a Neuron . . . . . . . . . . . . . . . . . . . . . . . . 57
4.8.3 QUARTUS Prime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.8.4 VHDL Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.8.5 Conversion of Parameters to Fixed-Point . . . . . . . . . . . . . . . . . . . . 58
4.8.5.1 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.8.5.2 VHDL Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.9 VHDL Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.9.1 Programmes VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.9.1.1 Instantiating "hidden2" Neuron Entity . . . . . . . . . . . . . . . . 63
4.9.1.2 Instantiating "output0" Neuron Entity . . . . . . . . . . . . . . . . 63
4.9.1.3 Instantiating "control" Entity . . . . . . . . . . . . . . . . . . . . . 64
4.9.1.4 Process for Control and Input Signals . . . . . . . . . . . . . . . . 64
4.9.1.5 Process for Output and Result Calculation . . . . . . . . . . . . . . 65
4.9.1.6 Assigning Clock and LED Signals . . . . . . . . . . . . . . . . . . . 65
4.9.2 Testing on Remote Lab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

2
 4.9.2.1 FPGA Vision Remote Lab . . . . . . . . . . . . . . . . . . . . . . . 65
4.9.2.2 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.9.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5 conclusion 68

6 Appendices 70

3
List of Figures

4.1 image of a lung with a tumor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

4.2 image of a lung with a tumor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3 Professor Marco Winzker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.4 neural network structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.5 fixed point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.6 floating point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.7 GNU Octave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.8 Training Image and label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.9 compilation output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.10 Cost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.11 prediction output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.12 QUARTUS Prime Logo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.13 Script for converting parameters from floating-point to fixed-point. . . . . . . . . . . 59
4.14 Results of the conversion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.15 FPGA Vision Remote Lab Icon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.16 FPGA Vision Remote Lab Output . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

4
Chapter 1

Introduction

1.1 General Context

Computer Vision is one of the applications of deep neural networks that enables us to automate
tasks that earlier required years of expertise and one such use in predicting the presence of can-
cerous cells.

In this article, we will build a classifier using a simple Convolution Neural Network which can
classify normal lung tissues from cancerous. This project used the dataset that has been taken
from Kaggle whose link has been provided as well.

The fields of artificial intelligence (AI) and hardware acceleration are converging to revolution-
ize healthcare, particularly in the domain of disease detection and diagnosis. One of the most
critical areas of medical research is the early detection of lung cancer, a disease that claims count-
less lives globally each year. This internship report delves into a transformative journey undertaken
at the intersection of AI, medical imaging, and field-programmable gate array (FPGA) technology,
aiming to contribute to the fight against lung cancer.

1.1.1 3d smart factory

3D SMART FACTORY is an innovative company dedicated to empowering young entrepreneurs
to champion their ideas and bring their projects to fruition. We understand the challenges faced
by aspiring entrepreneurs, and our mission is to provide comprehensive support throughout their
journey, from the initial stages of research to the final stages of production. Our overarching goal
is to have a positive impact on both the economy and social development.

1.1.1.1 Our Mission:

At 3D SMART FACTORY, our mission is crystal clear: to guide entrepreneurs from the inception
of their ideas to the realization of tangible products or services, all while striving to make a positive
impact on the economy and societal advancement.
We firmly believe that it is easy to create a business venture that may lack a positive societal
impact, and it is even easier to create one that might have a negative impact. However, what

5
truly sets us apart is our commitment to fostering economic growth while simultaneously promot-
ing positive societal change. This requires thoughtful planning, guidance, market analysis, and
meticulous execution.

In a world where businesses can shape communities and influence lives, we are dedicated to
supporting entrepreneurs who seek not only to succeed financially but also to contribute positively
to the world around them. At 3D SMART FACTORY, we are more than a company; we are a
partner in your entrepreneurial journey, committed to making your vision a reality and ensuring
it leaves a lasting, positive mark on society.

1.2 Background
Lung cancer is a pervasive global health challenge, representing a substantial portion of cancer-
related morbidity and mortality. Its asymptomatic nature during the early stages often leads to

6
late diagnosis, reducing the efficacy of treatment options and diminishing patient survival rates.
The urgency to improve early detection methods has spurred innovation in the application of AI
and deep learning techniques to medical imaging data.

1.3 Objectives
The primary objective of this internship was to develop a robust Convolutional Neural Network
(CNN) model for the automated detection of lung cancer from chest X-ray images. Furthermore,
the project aimed to implement this model on an FPGA using Xilinx tools to enable real-time
inference. The integration of AI and FPGA promised to unlock new possibilities in terms of accu-

7
racy, efficiency, and cost-effectiveness in the field of medical imaging.

This internship represents a significant step towards harnessing the potential of AI and FPGA
in improving the early detection of lung cancer. The project’s outcomes not only contribute to the
advancement of medical science but also underscore the importance of interdisciplinary collabora-
tion in addressing complex healthcare challenges.

Let us now embark on this journey, exploring the methodologies, achievements, challenges, and
ethical considerations that have shaped the development of a CNN lung cancer detection model
and its FPGA implementation.

8
Chapter 2

Literature Review

The intersection of artificial intelligence (AI) and healthcare has witnessed remarkable advance-
ments in recent years, with a particular emphasis on leveraging AI for disease detection and
diagnosis. This literature review section provides an overview of the existing research and develop-
ments in three key areas: lung cancer detection, AI in healthcare, and FPGA-based AI acceleration.

2.1 Lung Cancer Detection

Lung cancer is a global health crisis, representing a significant burden on both healthcare systems
and patients. Early detection of lung cancer is crucial for improving patient outcomes and survival
rates. Traditionally, radiologists have relied on the visual analysis of chest X-rays and computed
tomography (CT) scans to identify abnormalities. However, the subjectivity of visual interpreta-
tion and the sheer volume of medical images have necessitated the integration of AI into the process.

Deep Learning for Lung Cancer Detection: Recent research has demonstrated the potential
of deep learning techniques, particularly Convolutional Neural Networks (CNNs), in automating
the detection of lung cancer from medical images. Recent CNN Models have shown remarkable
accuracy in identifying lung nodules and abnormalities in chest X-rays and CT scans.

Dataset Availability: The emergence of large-scale and publicly available datasets, such as the
Lung Image Database Consortium (LIDC) and the ChestX-ray14 dataset, has facilitated research
in this domain. These datasets have played a pivotal role in training and evaluating AI models for
lung cancer detection.

2.2 AI in Healthcare
The application of AI in healthcare is a rapidly evolving field with a multitude of applications
beyond disease detection. AI-powered medical imaging, predictive analytics, and personalized
medicine are reshaping the way healthcare is delivered.

AI for Medical Imaging: AI algorithms are increasingly used in radiology and medical imag-
ing to assist radiologists in interpreting images more accurately and efficiently. AI-driven image

9
analysis has shown promise in various medical domains, including detecting cancer, identifying
fractures, and segmenting organs.

Clinical Decision Support Systems (CDSS): AI-based CDSSs are being developed to aid clini-
cians in diagnosing diseases and recommending treatment plans. These systems combine patient
data, medical literature, and AI algorithms to provide evidence-based guidance.

2.3 FPGA-Based AI Acceleration

The integration of field-programmable gate arrays (FPGAs) with AI has garnered attention due
to the potential for high-speed, energy-efficient inference.

Hardware Acceleration for AI: FPGAs are gaining popularity as hardware platforms for AI
inference. Their reconfigurability and parallel processing capabilities make them suitable for de-
ploying AI models in resource-constrained environments.

FPGA in Medical Imaging: In the context of medical imaging, FPGA-based solutions have
been explored to accelerate image processing and analysis tasks. The parallel nature of FPGA ar-
chitecture aligns well with the computational demands of AI algorithms applied to medical images.

2.4 Integration of AI and FPGA in Healthcare

The combination of AI and FPGA holds promise for accelerating AI-driven medical applications,
including image analysis, signal processing, and real-time diagnosis.

Real-Time Inference: FPGA-based AI acceleration enables real-time inference, a critical re-

quirement in medical applications where timely diagnosis and decision-making are imperative.

Resource Optimization: FPGA designs can be optimized to minimize resource utilization while
maximizing performance, making them well-suited for medical devices with size and power con-
straints.

This literature review underscores the significance of AI in healthcare, particularly in the con-
text of lung cancer detection, and the potential for FPGA-based acceleration to enhance real-time
inference and resource efficiency. As we delve further into the methodologies and outcomes of this
internship project, we build upon the rich landscape of existing research and developments in these
areas.

Introduction to Convolutional Neural Networks (CNNs)

Convolutional Neural Networks (CNNs) are a class of deep learning neural networks specifically
designed for processing structured grid data, such as images and videos. They have revolutionized

10
the field of computer vision and have become the backbone of various applications, from image
recognition and object detection to medical image analysis and autonomous vehicles. CNNs have
excelled in tasks where understanding the spatial hierarchies and patterns in data is crucial.

Key Components of CNNs:

1. Convolutional Layers: CNNs are characterized by their use of convolutional layers. These
layers apply convolution operations to the input data. Convolution involves sliding a small
filter (also called a kernel) across the input data to extract features. These features can
represent edges, textures, or more complex patterns.

2. Pooling Layers: After convolutional layers, pooling layers are often used to reduce spatial
dimensions and computational complexity. Max-pooling and average-pooling are common
pooling operations that select the maximum or average value within a small region of the
input, respectively.

3. Activation Functions: Activation functions like ReLU (Rectified Linear Unit) are applied
after convolution and pooling operations to introduce non-linearity into the network. ReLU,
for example, replaces negative values with zeros, helping the network learn complex, non-
linear relationships.

4. Fully Connected Layers: After feature extraction through convolution and pooling, fully
connected layers are used for classification or regression tasks. These layers connect every
neuron in one layer to every neuron in the next layer, allowing the network to learn high-level
features and make predictions.

Advantages of CNNs:
1. Hierarchical Feature Learning: CNNs automatically learn hierarchical representations
of data. Lower layers capture simple features like edges and textures, while higher layers
capture more abstract and complex patterns.

11
 2. Translation Invariance: CNNs are well-suited for tasks where the location of features in
the input data doesn’t matter much. Convolutional layers inherently provide translation-
invariant properties.

3. Scalability: CNNs can be scaled to handle various input sizes and complexities. This
scalability makes them applicable to a wide range of computer vision tasks.

4. State-of-the-Art Performance: CNNs have consistently achieved state-of-the-art perfor-

mance in image-related tasks, including image classification, object detection, and segmen-
tation.

Applications of CNNs:
1. Image Classification: CNNs can classify images into predefined categories, making them
invaluable in applications like image recognition.

2. Object Detection: They can identify and locate objects within an image, which is vital in
fields such as autonomous driving and surveillance.

3. Semantic Segmentation: CNNs can classify each pixel in an image, enabling fine-grained
understanding of visual data.

4. Medical Imaging: CNNs have been used for disease detection and medical image analysis,
including diagnosing cancer from X-rays or MRI scans.

5. Natural Language Processing: CNNs can also be adapted for processing sequences of
data, such as text and speech.

In summary, Convolutional Neural Networks have revolutionized computer vision and have
found applications in a wide range of fields. They are powerful tools for feature extraction and
hierarchical learning, making them a fundamental component of modern deep learning.

Mathematical Equations of CNN

In Convolutional Neural Networks (CNNs), several mathematical equations are used for image
processing and deep learning. Here are some of the key equations:

Convolution Operation:
The convolution operation between an input image (I) and a convolutional filter (K) at a particular
spatial location (x, y) can be represented as:
m n
2
X 2
X
(I ∗ K)(x, y) = I(x + i, y + j) · K(i, j)
i=− m
2
j=− n
2

where I(x, y) is the pixel value at location (x, y) in the input image, K(i, j) is the weight of the
filter at location (i, j), and m and n are the dimensions of the filter.

12
ReLU Activation:
The Rectified Linear Unit (ReLU) activation function is commonly used in CNNs and is defined
as:
ReLU(x) = max(0, x)
It replaces negative values with zero and leaves positive values unchanged.

Pooling Operation:
Max-pooling, for example, selects the maximum value within a pooling window:

Max-Pooling(x, y) = max I(x + i, y + j)

i,j

Average-pooling computes the average value within the window.

Fully Connected Layer:

In a fully connected layer, the output (O) is calculated as a weighted sum of the inputs (X) followed
by an activation function: !
X
O = Activation W i · Xi + b
i

where Wi represents the weight of the i-th connection, Xi is the i-th input, b is the bias term, and
the activation function applies an element-wise non-linear transformation to the weighted sum.

Cross-Entropy Loss:
Cross-entropy loss is a common loss function for classification tasks and is defined as:
X
CrossEntropy(y, ŷ) = − yi · log(ŷi )
i

where yi is the true label for class i and ŷi is the predicted probability for class i (output of the
softmax function).

Backpropagation:
Backpropagation uses the chain rule of calculus to update the model’s weights. For example, when
computing the gradient of the loss with respect to the weights in a fully connected layer:
∂Loss ∂Loss ∂Output
= ·
∂Wi ∂Output ∂Wi
Similar equations are used for convolutional layers and pooling layers during the backpropagation
process.
These mathematical equations form the foundation of how CNNs process and learn from image
data, making them powerful tools for computer vision tasks.

13
Chapter 3

CNN Model

3.1 Methodology
The successful development of a Convolutional Neural Network (CNN) lung cancer detection model
and its subsequent implementation in FPGA involved a systematic methodology encompassing
data collection, model development, training, FPGA design, and evaluation. This section outlines
the key steps undertaken during the internship project.

The first phase of the project involved the selection of a suitable dataset for training and
evaluating the CNN model. The dataset was chosen to ensure diversity, representativeness, and
relevance to lung cancer detection in medical practice.

To prepare the dataset for model training, a series of preprocessing steps were applied, including:

Resizing images to a consistent dimension.

Normalization to standardize pixel values.
Augmentation to increase dataset variability.
Splitting the data into training, validation, and test sets to ensure robust model evaluation.

Ethical Considerations

Throughout the project, ethical considerations were addressed, focusing on patient data privacy,
bias mitigation, and adherence to medical regulations. Strategies for responsible AI deployment
in healthcare were integrated into the project.

This methodology outlines the systematic approach employed to develop a CNN lung cancer
detection model and implement it in FPGA. The subsequent sections of this report will delve into
the specifics of each phase, including data collection, model architecture, FPGA design, results,
and ethical considerations.

14
3.2 Model development
Modules Used
Python libraries make it very easy for us to handle the data and perform typical and complex
tasks with a single line of code.

Pandas – This library helps to load the data frame in a 2D array format and has multiple
functions to perform analysis tasks in one go.
Numpy – Numpy arrays are very fast and can perform large computations in a very short time.
Matplotlib – This library is used to draw visualizations.
Sklearn – This module contains multiple libraries having pre-implemented functions to perform
tasks from data preprocessing to model development and evaluation.
OpenCV – This is an open-source library mainly focused on image processing and handling.
Tensorflow – This is an open-source library that is used for Machine Learning and Artificial intelli-
gence and provides a range of functions to achieve complex functionalities with single lines of code.

Importing Dataset

The dataset which we will use here has been taken from
-https://www.kaggle.com/datasets/andrewmvd/lung-and-colon-cancer-histopathological-images.
This dataset includes 5000 images for three classes of lung conditions:

15
 Normal Class
Lung Adenocarcinomas
Lung Squamous Cell Carcinomas
These images for each class have been developed from 250 images by performing Data Augmenta-
tion on them. That is why we won’t be using Data Augmentation further on these images.

we can see the amount of images we have in which tumors are red.

16
3.2.1 Data Visualization
In this section, we will try to understand visualize some images which have been provided to us to
build the classifier for each class.

These are the three classes that we have here.

17
 this code will randomly select images from the dataset and plot it.
Objective: The code is intended to display random images from different categories stored in a
directory structure. It utilizes Python libraries such as os for file operations, numpy for random
number generation, PIL (Pillow) for image manipulation, and matplotlib for image visualization.

18
 The above output may vary if you will run this in your notebook because the code has been
implemented in such a way that it will show different images every time you rerun the code.

3.2.2 Data preparation for training

In this section, we will convert the given images into NumPy arrays of their pixels after resizing
them because training a Deep Neural Network on large-size images is highly inefficient in terms of
computational cost and time.

19
 For this purpose, we will use the OpenCV library and Numpy library of python to serve the
purpose. Also, after all the images are converted into the desired format we will split them into
training and validation data so, that we can evaluate the performance of our model.

Some of the hyperparameters which we can tweak from here for the whole notebook.

3.2.2.1 HotEncoding:
Most real-life datasets we encounter during our data science project development have columns of
mixed data type. These datasets consist of both categorical as well as numerical columns. How-
ever, various Machine Learning models do not work with categorical data and to fit this data into
the machine learning model it needs to be converted into numerical data. For example, suppose a
dataset has a Gender column with categorical elements like Male and Female. These labels have
no specific order of preference and also since the data is string labels, machine learning models
misinterpreted that there is some sort of hierarchy in them.

One approach to solve this problem can be label encoding where we will assign a numerical
value to these labels for example Male and Female mapped to 0 and 1. But this can add bias in
our model as it will start giving higher preference to the Female parameter as 1>0 but ideally,
both labels are equally important in the dataset. To deal with this issue we will use the One Hot
Encoding technique.

One hot encoding is a technique that we use to represent categorical variables as numerical
values in a machine learning model.

20
 One hot encoding will help us to train a model which can predict soft probabilities of an image
being from each class with the highest probability for the class to which it really belongs.

In this step, we will achieve the shuffling of the data automatically because the train-test-split
function split the data randomly in the given ratio.

3.2.3 Model Development

From this step onward we will use the TensorFlow library to build our CNN model. Keras frame-
work of the tensor flow library contains all the functionalities that one may need to define the

21
architecture of a Convolutional Neural Network and train it on the data.

3.2.4 Tensorflow
TensorFlow is an open-source machine learning framework developed by the Google Brain team.
It is one of the most popular deep learning frameworks used for various machine learning and
artificial intelligence tasks, including neural networks, natural language processing, computer vi-
sion, and reinforcement learning. TensorFlow provides a flexible and comprehensive ecosystem
for developing, training, and deploying machine learning models. Here are some key features and
components of TensorFlow:

TensorFlow 2.x: TensorFlow 2.x is the latest version of the framework and includes many im-
provements over the earlier versions. It offers an easier-to-use API, improved compatibility with
Python, and better support for dynamic computation graphs.

Tensors: Tensors are the fundamental data structures in TensorFlow. They are multi-dimensional
arrays that can represent data of various types, such as scalars, vectors, matrices, and higher-
dimensional data.

Computation Graph: TensorFlow uses a computation graph to represent machine learning

models. The graph defines the operations and dependencies between tensors. TensorFlow 2.x
allows for dynamic computation graphs, making it more intuitive for users.

Keras Integration: TensorFlow 2.x includes Keras as its high-level API for defining and training
neural networks. Keras provides a user-friendly interface for building and training deep learning

22
models.

I used Keras to develop my lung cancer detection system.

Layers and Models: TensorFlow offers a wide range of pre-built layers and models for common
deep learning architectures, making it easier to create complex neural networks.

Automatic Differentiation: TensorFlow provides automatic differentiation, which is essential

for training neural networks using gradient-based optimization algorithms like backpropagation.

GPU and TPU Support: TensorFlow can leverage GPUs (Graphics Processing Units) and
TPUs (Tensor Processing Units) for accelerated model training and inference, making it suitable
for large-scale deep learning tasks.

TensorBoard: TensorFlow includes TensorBoard, a visualization tool for monitoring and de-
bugging machine learning models. It allows you to visualize training metrics, model graphs, and
other relevant information.

Data Input Pipelines: TensorFlow provides tools for building efficient data input pipelines us-
ing the tf.data API. This helps manage data preprocessing and feeding data to your models during
training.

Saved Models: TensorFlow allows you to save and export trained models for later use in pro-
duction or for sharing with others.

Deployment Options: TensorFlow supports various deployment options, including TensorFlow

Serving for serving models in production, TensorFlow Lite for mobile and embedded devices, and
TensorFlow.js for web applications.

Community and Ecosystem: TensorFlow has a large and active community of developers and
researchers. There are numerous resources, libraries, and pre-trained models available for various
machine learning tasks.

TensorFlow Extended (TFX): TensorFlow Extended is an end-to-end platform for deploying

production machine learning pipelines. It includes tools for data validation, feature engineering,
model training, and serving.

TensorFlow is widely used in academia and industry and has been applied to a wide range of
applications, including image recognition, natural language processing, speech recognition, recom-
mendation systems, and more. It continues to evolve with ongoing development and improvements
to support the latest advances in machine learning and deep learning research.

3.2.4.1 Model Architecture

We will implement a Sequential model which will contain the following parts:

23
 Three Convolutional Layers followed by MaxPooling Layers.
The Flatten layer to flatten the output of the convolutional layer.
Then we will have two fully connected layers followed by the output of the flattened layer.
We have included some BatchNormalization layers to enable stable and fast training and a Dropout
layer before the final layer to avoid any possibility of overfitting.
The final layer is the output layer which outputs soft probabilities for the three classes.

model = k e r a s . models . S e q u e n t i a l ( [
l a y e r s . Conv2D ( f i l t e r s =32 ,
k e r n e l _ s i z e =(5 , 5 ) ,
a c t i v a t i o n =’ r e l u ’ ,
input_shape=(IMG_SIZE ,
IMG_SIZE ,
3) ,
padding =’same ’ ) ,
l a y e r s . MaxPooling2D ( 2 , 2 ) ,

l a y e r s . Conv2D ( f i l t e r s =64 ,
k e r n e l _ s i z e =(3 , 3 ) ,
a c t i v a t i o n =’ r e l u ’ ,
padding =’same ’ ) ,
l a y e r s . MaxPooling2D ( 2 , 2 ) ,

l a y e r s . Conv2D ( f i l t e r s =128 ,
k e r n e l _ s i z e =(3 , 3 ) ,
a c t i v a t i o n =’ r e l u ’ ,
padding =’same ’ ) ,
l a y e r s . MaxPooling2D ( 2 , 2 ) ,

layers . Flatten () ,
layers . Dense ( 2 5 6 , a c t i v a t i o n =’ r e l u ’ ) ,
layers . BatchNormalization ( ) ,
layers . Dense ( 1 2 8 , a c t i v a t i o n =’ r e l u ’ ) ,
layers . Dropout ( 0 . 3 ) ,
layers . BatchNormalization ( ) ,
layers . Dense ( 3 , a c t i v a t i o n =’ softmax ’ )
])
Let’s print the summary of the model’s architecture:

model . summary ( )
Model : sequential

_________________________________________________________________

Layer ( type ) Output Shape Param #

24
=================================================================

conv2d ( Conv2D ) ( None , 2 5 6 , 2 5 6 , 3 2) 2432

max_pooling2d ( MaxPooling2D ( None , 1 2 8 , 1 2 8 , 3 2) 0

conv2d_1 ( Conv2D ) ( None , 1 2 8 , 1 2 8 , 64 ) 18496

max_pooling2d_1 ( MaxPooling ( None , 6 4 , 6 4 , 64 ) 0

2D)

conv2d_2 ( Conv2D ) ( None , 6 4 , 6 4 , 128 ) 73856

max_pooling2d_2 ( MaxPooling ( None , 3 2 , 3 2 , 128) 0

2D)

f l a t t e n ( Flatten ) ( None , 131072) 0

dense ( Dense ) ( None , 256) 33554688

b a t c h _ n o r m a l i z a t i o n ( BatchN ( None , 256) 1024

normalization )

dense_1 ( Dense ) ( None , 128 ) 32896

25
 dropout ( Dropout ) ( None , 128) 0

batch_normalization_1 ( Batc ( None , 128) 512

hNormalization )

dense_2 ( Dense ) ( None , 3 ) 387

=================================================================

T ot a l params : 3 3 , 6 8 4 , 2 9 1

T r a i n a b l e params : 3 3 , 6 8 3 , 5 2 3

Non−t r a i n a b l e params : 768

From above we can see the change in the shape of the input image after passing through differ-
ent layers. The CNN model we have developed contains about 33.5 Million parameters. This huge
number of parameters and complexity of the model is what helps to achieve a high-performance
model which is being used in real-life applications.

26
27
 While compiling a model we provide these three essential parameters:

optimizer – This is the method that helps to optimize the cost function by using gradient de-
scent.
loss – The loss function by which we monitor whether the model is improving with training or not.
metrics – This helps to evaluate the model by predicting the training and the validation data.

3.2.4.2 Callback
Callbacks are used to check whether the model is improving with each epoch or not. If not then
what are the necessary steps to be taken like ReduceLROnPlateau decreases learning rate further.
Even then if model performance is not improving then training will be stopped by EarlyStopping.
We can also define some custom callbacks to stop training in between if the desired results have
been obtained early.

3.2.4.3 Model training

Now we will train our model:

28
 The batch size is a number of samples processed before the model is updated. The number of
epochs is the number of complete passes through the training dataset.

Let’s visualize the training and validation accuracy with each epoch.

h i s t o r y _ d f = pd . DataFrame ( h i s t o r y . h i s t o r y )
history_df . loc [ : , [ ’ loss ’ , ’ val_loss ’ ] ] . plot ()
h i s t o r y _ d f . l o c [ : , [ ’ accuracy ’ , ’ val_accuracy ’ ] ] . p l o t ( )
p l t . show ( )

29
From the above graphs, we can certainly say that the model has not overfitted the training data
as the difference between the training and validation accuracy is very low.

3.2.5 Model Evaluation

Now as we have our model ready let’s evaluate its performance on the validation data using dif-
ferent metrics. For this purpose, we will first predict the class for the validation data using this
model and then compare the output with the true labels.

Y_pred = model . p r e d i c t ( X_val )

Y_val = np . argmax ( Y_val , a x i s =1)
Y_pred = np . argmax ( Y_pred , a x i s =1)
Let’s draw the confusion metrics and classification report using the predicted labels and the
true labels.

m e t r i c s . c o n f u s i o n _ m a t r i x ( Y_val , Y_pred )

30
 p r i n t ( m e t r i c s . c l a s s i f i c a t i o n _ r e p o r t ( Y_val , Y_pred ,
target_n

3.2.6 Conclusion
Indeed the performance of our simple CNN model is very good as the f1-score for each class is
above 0.90 which means our model’s prediction is correct 90 percent of the time. This is what
we have achieved with a simple CNN model what if we use the Transfer Learning Technique to
leverage the pre-trained parameters which have been trained on millions of datasets and for weeks
using multiple GPUs? It is highly likely to achieve even better performance on this dataset.

31
Chapter 4

FPGA Implementation

4.1 General overview

FPGA (Field-Programmable Gate Array) implementation for a CNN lung cancer detection model
involves translating the trained CNN model into hardware description language (HDL) suitable
for FPGA deployment. Below is a high-level overview of the FPGA implementation process, along
with some key considerations:

1. Hardware Description Language (HDL):

Describing the hardware components of a CNN (Convolutional Neural Network) model in an

HDL (Hardware Description Language) such as VHDL or Verilog is a complex and resource-
intensive task due to the intricacies of neural network operations. It’s important to note that
while it’s possible to implement CNNs in HDL for FPGA deployment, it’s typically not the most
efficient approach due to the complexity and resource requirements.

Instead, the common practice for implementing CNN models on FPGAs is to use high-level
synthesis (HLS) tools provided by FPGA development environments like Xilinx Vivado HLS or
Intel HLS. These tools allow you to describe the high-level behavior of the CNN model in C/C++
code, and then the tool automatically generates the RTL (Register Transfer Level) code in VHDL
or Verilog.

we describe a basic convolutional layer in VHDL using the code below:

l i b r a r y IEEE ;
us e IEEE . STD_LOGIC_1164 . ALL ;
us e IEEE .STD_LOGIC_ARITH. ALL ;
us e IEEE .STD_LOGIC_UNSIGNED. ALL ;

e n t i t y C o n v o l u t i o n L a y er i s
Port ( c l k : i n STD_LOGIC;
r e s e t : i n STD_LOGIC;
i n p u t _ v a l i d : i n STD_LOGIC;
input_data : i n STD_LOGIC_VECTOR( 7 downto 0 ) ;
o u t pu t _ v al i d : out STD_LOGIC;

32
 output_data : out STD_LOGIC_VECTOR( 7 downto 0 ) ) ;
end C o n v o l u ti o n L a y e r ;

a r c h i t e c t u r e B e h a v i o r a l o f C o n v o l u t i o n L ay e r i s
−− D e f i n e p a r a m e t e r s f o r th e c o n v o l u t i o n o p e r a t i o n
c o n s t a n t KERNEL_SIZE : i n t e g e r := 3 ;
c o n s t a n t STRIDE : i n t e g e r := 1 ;

−− D e f i n e t h e k e r n e l w e i g h t s ( s i m p l i f i e d f o r i l l u s t r a t i o n )
type k e r n e l _ t i s a r r a y ( 0 t o KERNEL_SIZE−1, 0 t o KERNEL_SIZE−1) o f STD_LOGIC_VE
c o n s t a n t k e r n e l : k e r n e l _ t := (
(X" 0 1 " , X" 0 2 " , X" 0 1 " ) ,
(X" 0 2 " , X" 0 4 " , X" 0 2 " ) ,
(X" 0 1 " , X" 0 2 " , X"01")
);

−− I n t e r n a l s i g n a l s
s i g n a l c o n v o l u t i o n _ r e s u l t : STD_LOGIC_VECTOR( 7 downto 0 ) ;

begin
process ( clk , r e s e t )
begin
i f r e s e t = ’ 1 ’ then
−− Reset i n t e r n a l s t a t e i f needed
e l s i f r i s i n g _ e d g e ( c l k ) then
i f i n p u t _ v a l i d = ’ 1 ’ then
−− Perform c o n v o l u t i o n o p e r a t i o n h e r e u s i n g t h e k e r n e l w e i g h t s
−− This i n v o l v e s m u l t i p l y i n g th e k e r n e l with t he input_data
−− and summing th e r e s u l t s t o o b t a i n c o n v o l u t i o n _ r e s u l t

−− S i m p l i f i e d example : a s s i g n input_data t o c o n v o l u t i o n _ r e s u l t
c o n v o l u t i o n _ r e s u l t <= input_data ;

−− S et o u t pu t _ v al i d t o i n d i c a t e v a l i d output data
o u t pu t _ v al i d <= ’ 1 ’ ;
else
o u t pu t _ v al i d <= ’ 0 ’ ;
end i f ;
end i f ;
end p r o c e s s ;

−− Output data
output_data <= c o n v o l u t i o n _ r e s u l t ;

end B e h a v i o r a l ;

33
4.1.1 Mapping the CNN Model:
Mapping the CNN layers to appropriate FPGA hardware components involves selecting the right
FPGA resources for specific operations within each layer of the neural network. Below, I’ll provide
a high-level mapping of typical CNN layers to FPGA resources, with a focus on Xilinx FPGAs:
1. Convolutional Layers:
Convolution Operation: Implement the convolution operation using FPGA DSP (Digital Signal
Processing) slices. FPGA DSP slices are optimized for multiply-accumulate operations, making
them ideal for convolution.
Weight Storage: Utilize FPGA block RAM (BRAM) for weight storage. Each filter’s weights
can be stored in BRAM, allowing for fast access during convolution.
Data Flow: Ensure that the data flow within the FPGA for convolution follows the forward
pass of the CNN model. Input data is read from BRAM, convolved with weights using DSP slices,
and the results are accumulated.
Pooling Layers: FPGA resources like BRAM or distributed RAM can be used to store inter-
mediate results during pooling operations. The pooling operation itself can be implemented using
FPGA logic.
2. Fully Connected Layers:
Matrix Multiplication: Fully connected layers involve matrix multiplication between the out-
put of the previous layer and the layer’s weights. Implement matrix multiplication using FPGA
multipliers and adders.
Weight Storage: Store fully connected layer weights in FPGA BRAM for quick access during
matrix multiplication.
Data Flow: Design the data flow to efficiently perform matrix multiplication. The input
activations are read from BRAM, multiplied with weights using multipliers, and the results are
accumulated using adders.
3. Data Flow and Pipelining:
To optimize performance, pipeline the data flow within the FPGA. Pipeline stages can overlap
computation and data movement, improving throughput.
Ensure that data dependencies are handled correctly to avoid pipeline stalls.
Implement appropriate control logic to manage data movement between different FPGA com-
ponents (e.g., BRAM, DSP slices, multipliers).
4. Data Input/Output:
Define interfaces for data input and output to the FPGA. Typically, data input is via external
interfaces (e.g., DDR memory), and data output is through appropriate output interfaces.
Implement efficient data transfer mechanisms to move input data to BRAM and output results
from the FPGA.
5. Optimization for Resource Efficiency:
Resource utilization is critical in FPGA design. Optimize the allocation of DSP slices, BRAM,
and other resources to maximize performance while minimizing resource usage.
Consider quantization and model compression techniques to reduce resource requirements.
6. Real-Time Inference:
Ensure that the data flow and hardware components meet the required throughput for real-time
inference. This is crucial for applications like medical image analysis. 7. Testing and Verification:
Rigorously test and verify the FPGA design using simulation tools and, if possible, hardware
emulation.

34
 Verify that the FPGA-accelerated model produces results consistent with the original CNN
model.

4.1.2 FPGA Toolchain:

we can use FPGA development tools, such as Xilinx Vivado or Intel Quartus, to compile, synthesize,
and program the FPGA. we can Create a new FPGA project and specify the target FPGA device.

4.1.2.1 VHDL Implementation of a Feedforward Neural Network Layer

convulotional layer:
−− C o n v o l u t i o n a l Layer E n t i t y
entity ConvLayer i s
Port (
clk : in s t d _ l o g i c ;
rst : in s t d _ l o g i c ;
input : in s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− 8− b i t i n p u t p i x e l
output : out s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− 8− b i t o u t p u t f e a t u r e m
v a l i d _ o u t : out s t d _ l o g i c ;
−− Add o t h e r n e c e s s a r y p o r t s f o r w e i g h t s , b i a s , k e r n e l s i z e , e t c .
);
end entity ConvLayer ;

architecture B e h a v i o r a l of ConvLayer i s
−− D e f i n e i n t e r n a l s i g n a l s and r e g i s t e r s
s i g n a l sum : i n t e g e r := 0 ;
begin
−− VHDL code f o r t h e ConvLayer module

−− . . .

end architecture B e h a v i o r a l ;
Fully Connected Layer
−− F u l l y Connected Layer E n t i t y ( S i m p l i f i e d )
entity FullyConnectedLayer i s
Port (
clk : in s t d _ l o g i c ;
rst : in s t d _ l o g i c ;
input : in s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− 8− b i t i n p u t
output : out s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− 8− b i t o u t p u t
v a l i d _ o u t : out s t d _ l o g i c ;
−− Add o t h e r n e c e s s a r y p o r t s f o r w e i g h t s , b i a s , e t c .
);
end entity FullyConnectedLayer ;

architecture B e h a v i o r a l of FullyConnectedLayer i s

35
 −− D e f i n e i n t e r n a l s i g n a l s and r e g i s t e r s
s i g n a l sum : i n t e g e r := 0 ;
begin
−− VHDL code f o r t h e F u l l y C o n n e c t e d L a y e r module

−− . . .

end architecture B e h a v i o r a l ;

4.2 Implementation of a neural network model that detects

lung cancer images on FPGA

Figure 4.1: image of a lung with a tumor

36
Figure 4.2: image of a lung with a tumor

37
4.3 Presentation of the Problem
I have referenced in this part on the youtube playlist created by Professor Marco Winzker unti-
tled Machine learning on FPGA https://youtube.com/playlist?list=PLGzeDuLmmxDpEsCAjf_
sYrMC6p-Y0Ummk&si=kAMCVAgNZ2T9_0w_

Figure 4.3: Professor Marco Winzker

Professor for Digital Circuit Design at Bonn-Rhein-Sieg University of Applied Sciences Head
of Centre for Teaching Development and Innovation.

4.3.1 Problem Statement

In this chapter, the objective is to address the challenge of developing an effective neural network
model for the specific task of lung cancer detection, with a focus on detecting the tumor. This
problem encompasses the following key aspects:

1. Color-Based Detection: The task involves designing a neural network capable of rec-
ognizing and distinguishing tumors based on their red color. This is crucial for medical
applications that works of detecting this kind of tumors .

38
 2. Model Training: The challenge is to train the neural network to accurately identify red
tumors from a diverse set of images. This entails selecting an appropriate dataset, defining
network architecture, and optimizing network parameters.

4.3.2 Importing Dataset

The dataset which we will use here has been taken from
-https://www.kaggle.com/datasets/andrewmvd/lung-and-colon-cancer-histopathological-images.
This dataset includes 5000 images for three classes of lung conditions:

Normal Class
Lung Adenocarcinomas
Lung Squamous Cell Carcinomas

These images for each class have been developed from 250 images by performing Data Aug-
mentation on them. That is why we won’t be using Data Augmentation further on these
images.

3. Parameter Determination: The goal is to determine the optimal weight and bias matrices
that describe the neural network model and ensure accurate tumor detection. This requires
a thorough training process and evaluation of the model’s performance.
4. Hardware Implementation: Beyond software development, the intention is to describe
the behavior of the trained model in VHDL, a hardware description language. This step is
essential for potential hardware acceleration and deployment in FPGA or ASIC devices.
Overall Objective: The primary objective is to develop a reliable and efficient neural network-
based solution for the detection of red tumors . By addressing this problem, we aim to contribute
to advancements in intelligent medical systems and computer vision applications.
Expected Outcomes: The expected outcomes include a well-trained neural network model
capable of accurately detecting red tumors, as well as the description of its behavior in VHDL for
potential hardware deployment. This solution has the potential to enhance the medical field and
contribute to the field of computer vision and intelligent medical systems.

4.4 Network Topology

This neural network is a feedforward neural network designed for a specific image classification
task. Here are the details about the neural network:

4.4.1 Network Structure

The network structure is defined as [3 3 1], which specifies the number of neurons in each layer:
• Input Layer: 3 neurons
The input layer has three neurons because the script works with color images where each
pixel typically has three color channels (e.g., Red, Green, Blue).

39
 • Hidden Layer: 3 neurons
There is one hidden layer with three neurons in this network. The hidden layer performs
intermediate computations to learn patterns in the input data.

• Output Layer: 1 neuron

The output layer has a single neuron, which is responsible for making binary classification
decisions. If the output value is greater than or equal to 0.5, the pixel is categorized as
"color," otherwise, it is categorized as "other."

Figure 4.4: neural network structure

4.4.2 Activation Function

The script uses a sigmoid activation function, as mentioned in the comments. The sigmoid func-
tion maps the weighted sum of inputs to a value between 0 and 1, which is suitable for binary
classification tasks.

4.4.3 Training
The network is trained using backpropagation and gradient descent. The training process involves
adjusting the network’s weights to minimize a cost function (likely a binary cross-entropy loss)
between the predicted output and the actual labels.

4.4.3.1 Training Parameters

• The number of training epochs is set to 400.

40
 • The learning rate (alpha) is set to 0.00001. This parameter controls the step size in weight
updates during training.

4.4.4 Prediction
After training, the network is used to make predictions on input images. The predicted output
values are rounded to 0 or 1 to determine the category of each pixel.

4.4.5 Results
The script generates a prediction picture where each pixel is assigned a color based on the network’s
classification decision. If the output value for a pixel is 1, it is assigned the "color1" color; otherwise,
it is assigned the "color0" color.

4.4.6 Saving Parameters

The script saves the trained network parameters, including the weight matrices from the input to
the hidden layer and from the hidden to the output layer. These saved parameters can potentially
be used for further analysis or implementation in other contexts.
In summary, the neural network is a simple feedforward network with one hidden layer, designed
for binary image classification tasks, where the goal is to categorize each pixel as "color" for white
or "other" means black based on the pixel’s color information. It uses a sigmoid activation function
and is trained using gradient descent to optimize a binary cross-entropy loss.

4.5 Data Representation and Network Parameters

4.5.1 Fixed-Point Format
A fixed-point number is represented with a fixed number of digits before and after the radix point.
In FPGA, a fixed-point number is stored as an integer that is scaled by a specific implicit factor.
For example, the common notation fix16_10 used by Xilinx stands for a 16-bit integer scaled by
. In other words, 10 out of the 16 bits are used to represent the fractional part and 6 bits for the
integer part.
Fixed-point arithmetic is widely used in FPGA-based algorithms because it usually runs faster
and uses fewer resources when compared to floating-point arithmetic.
However, one drawback of fixed-point arithmetic is that the user has to anticipate the range
of the data and choose the scaling factor accordingly (the size of the fractional part), making the
design more prone to errors.

Figure 4.5: fixed point

41
4.5.2 Floating-Point Format
Floating-point format is a method for representing real numbers in computers. It is widely used
because it allows for the representation of a broad range of values, including very large and very
small numbers, using a relatively small number of bits. The two most common floating-point
formats are the IEEE 754 single-precision and double-precision formats, which are used for 32-bit
and 64-bit representations, respectively.

4.5.2.1 Components of Floating-Point Format

A typical floating-point representation consists of several components:

• Sign Bit: The leftmost bit, often referred to as the most significant bit, indicates the sign
of the number. A 0 typically represents a positive number, while a 1 represents a negative
number.

• Exponent: The exponent component represents the power of 2 to which the number is
raised. It is usually biased, meaning a bias value is added or subtracted to allow for both
positive and negative exponents. This facilitates a wide range of representable values.

• Mantissa (or Significand): The mantissa contains the fractional part of the number and
holds the significant digits. In many formats, the mantissa is normalized, meaning it is
adjusted so that the leftmost bit is 1, effectively removing leading zeros.

• Base: The base of the floating-point format specifies the base number system. It is often 2
for binary floating-point formats (e.g., IEEE 754), but other bases, such as 10, can be used
in specialized formats.

• Precision: The precision of a floating-point format determines how many significant digits
can be represented. A larger number of bits allocated to the mantissa results in higher
precision.

• Range: The range of a floating-point format is determined primarily by the exponent.

It defines the minimum and maximum representable values. The exponent allows for the
representation of both very large and very small numbers.

• Special Values: Floating-point formats often include special values like positive and nega-
tive infinity, NaN (Not-a-Number), and zero, each with specific representations.

• Rounding: Due to limited precision, rounding errors can occur during arithmetic operations.
Rounding modes determine how these errors are handled.

4.5.2.2 IEEE 754 Floating-Point Formats

The most commonly used floating-point formats are the IEEE 754 single-precision (32-bit) and
double-precision (64-bit) formats. Single-precision uses 1 bit for the sign, 8 bits for the exponent
(biased), and 23 bits for the mantissa. Double-precision uses 1 bit for the sign, 11 bits for the
exponent (biased), and 52 bits for the mantissa.
These formats are widely employed in programming languages such as C, C++, Java, and
Python for the representation of real numbers in memory and for performing arithmetic operations

42
on them. They are essential in scientific, engineering, and other domains involving numerical
computations.

Figure 4.6: floating point

4.5.3 Converting from Floating-Point to Fixed-Point in FPGA

Converting from floating-point representation to fixed-point representation is a common and valu-
able practice in FPGA (Field-Programmable Gate Array) designs. This conversion offers several
advantages, including improved resource efficiency, deterministic behavior, and suitability for real-
time processing. Here are the key aspects to consider when converting from floating-point to
fixed-point in an FPGA-based application:

4.5.3.1 Resource Efficiency

Fixed-point arithmetic is more resource-efficient in terms of hardware utilization compared to
floating-point arithmetic. FPGA resources, including logic elements and memory, are often limited,
and optimizing resource usage is crucial. By converting to fixed-point, you can significantly reduce
resource requirements, allowing for more computations to be performed concurrently on the FPGA.

4.5.3.2 Deterministic Behavior

Fixed-point arithmetic is deterministic, meaning it produces the same results for the same inputs
every time. In contrast, floating-point arithmetic can introduce variability due to the finite preci-
sion of floating-point numbers. Deterministic behavior is crucial in applications where consistency
and repeatability are essential, such as medical systems and safety-critical systems.

4.5.3.3 Real-Time Processing

For real-time processing applications that require low-latency and predictable execution times,
fixed-point arithmetic is often the preferred choice. Fixed-point operations can be scheduled more
efficiently, making them suitable for tasks like digital signal processing (DSP) and real-time control
systems.

43
4.5.3.4 Reduced Data Transfer Overheads
When interfacing with external systems or communication protocols that use fixed-point data
formats, converting from floating-point to fixed-point can reduce data transfer overheads and
simplify integration. This is particularly important in embedded systems and communication
protocols where data compatibility is crucial.

4.5.3.5 Precision Control

Fixed-point representations allow for precise control over the number of bits allocated to the integer
and fractional parts. This control enables optimization of the representation to match the specific
range and precision requirements of the FPGA-based application.

4.5.3.6 Conversion Considerations

When converting from floating-point to fixed-point, it’s essential to carefully choose the fixed-point
format, including the word length and scaling factors, to avoid issues like overflow, underflow, and
loss of precision. The trade-off between resource efficiency and precision should also be carefully
considered to ensure that the converted representation meets the application’s accuracy require-
ments.
In summary, converting from floating-point to fixed-point in FPGA-based designs offers several
advantages, including improved resource efficiency and deterministic behavior. It is a valuable
technique for optimizing FPGA resource usage and achieving predictable and efficient real-time
processing.

4.6 Mathematical Modeling of the Neural Network

4.6.1 Neural Network Variables
Consider a feedforward neural network with the following architecture:

• Input Layer: 3 neurons

• Hidden Layer: 3 neurons

• Output Layer: 1 neuron

Let’s denote the following variables:

44
 Input layer activations:
(1) (1) (1)
a1 , a2 , a3
Hidden layer activations:
(2) (2) (2)
a1 , a2 , a3
Output layer activation:
(3)
a1
Weights and biases:
(1) (1)
wij (weights from input to hidden), bj (biases for hidden layer),
(2) (2)
wjk (weights from hidden to output), bk (bias for output layer)

4.6.2 Output Calculation

To compute the output of the neural network, we utilize the sigmoid activation function for the
single neuron in the output layer. Denoting the predicted output as ŷ, the equation for the output
is given by:
(3)
ŷ = σ(z1 ) (4.1)
Where:

• ŷ represents the predicted output.

• σ is the sigmoid activation function.

(3)
• z1 is the weighted sum of inputs to the output neuron before applying the sigmoid activation
function, calculated as:

(3) (2) (2) (2) (2) (2) (2) (2)

z1 = w11 a1 + w12 a2 + w13 a3 + b1 (4.2)

Where:
(2) (2) (2)
– w11 , w12 , and w13 are the weights from the hidden neurons to the output neuron.
(2) (2) (2)
– a1 , a2 , and a3 are the activations of the hidden neurons.
(2)
– b1 is the bias of the output neuron.

The sigmoid activation function σ(z) is defined as:

1
σ(z) = (4.3)
1 + e−z
This equation illustrates how the neural network calculates its output for a given input, in-
corporating the weighted sum of inputs and the sigmoid activation function. During training, the
network adjusts these weights and biases to optimize its predictions.

45
4.6.3 Weights from Hidden Neurons to Output Neuron
To express the weights from the hidden neurons to the output neuron in terms of the weights from
the 3 input neurons to the hidden neurons, we can use the following simplified equation:
3
X
(2) (1)
wjk = wij · ai (4.4)
i=1

Where:
(2)
• wjk represents the weight from the j-th hidden neuron to the output neuron k.
(1)
• wij represents the weight from the i-th input neuron to the j-th hidden neuron.
• ai represents the activation of the i-th input neuron.

4.6.4 Forward Propagation

The forward propagation of the neural network involves computing the activations of the hidden
and output layers based on the input data. It follows the equations mentioned in the previous
section for the sigmoid activation function.

4.6.5 Back Propagation

Backpropagation is a crucial step in training neural networks. During training, the goal is to
minimize a loss function that quantifies the error between the predicted output of the network and
the actual target values. The loss function, denoted as L, measures the quality of the network’s
predictions.
Let’s consider a single training example with input data x and target output y. The predicted
output of the network is denoted as ŷ.
The loss function L(ŷ, y) quantifies the difference between ŷ and y. Common loss functions
include mean squared error (MSE) for regression problems and cross-entropy loss for classification
problems. Here’s the mathematical representation of the loss function:

1
Mean Squared Error (MSE) : L(ŷ, y) = (ŷ − y)2
2
Cross-Entropy Loss (for binary classification) : L(ŷ, y) = −[y log(ŷ) + (1 − y) log(1 − ŷ)]

The goal of backpropagation is to adjust the network’s weights and biases to minimize this loss
function. This process involves calculating gradients with respect to the loss and updating the
parameters using optimization algorithms like gradient descent.
In the case of mean squared error, the gradient of the loss with respect to the predicted output
∇ŷ L is straightforward to compute:

∇ŷ L = ŷ − y
For cross-entropy loss, the gradient calculation is slightly more involved:
ŷ − y
∇ŷ L =
ŷ(1 − ŷ)

46
4.7 Network Training
4.7.1 Supervised Learning
In the field of machine learning, supervised learning involves the following key elements:

• Labeled Dataset: Supervised learning relies on a dataset that consists of pairs of input
examples and their corresponding correct output or labels.

• Model Objective: The primary objective of supervised learning is for a model to learn
how to make predictions or decisions based on input data.

• Training Process: During the training process, the model adjusts its parameters to mini-
mize the difference between its predictions and the actual labels in the dataset.

• Generalization: Once trained, the model aims to generalize its knowledge to make accurate
predictions on new, unseen data.

you are applying supervised learning to train a neural network. The details of your dataset,
including input images and their associated labels, are used for training. The neural network learns
to categorize pixels in images based on the labeled data. After training, the network can categorize
pixels in new, unseen images.
Supervised learning is a fundamental approach in machine learning, enabling models to learn
tasks by leveraging labeled examples.

4.7.2 Training with Octave

4.7.2.1 GNU Octave
GNU Octave is an open-source, high-level programming language and software primarily designed
for numerical computations and scientific computing. It serves as a MATLAB alternative, offering
compatibility with MATLAB syntax while being open-source and freely available. Key features
include support for matrix-based operations, extensive numerical computing capabilities, plotting
and visualization tools, cross-platform compatibility, and a strong focus on education and research
in fields like mathematics, engineering, and data science. Octave is used for various scientific and
engineering tasks and has an active user community.

47
 Figure 4.7: GNU Octave

4.7.2.2 Training Process Details

To delve into the training process of the neural network for image categorization, let’s explore the
key steps and parameters involved:

1. Constants Definition:

Code:

% Number o f e p o c h s you want t o t r a i n t h e network

epochs = 4 0 0 ;
% Learning r a t e f o r t h e t r a i n i n g p r o c e s s
a lp h a = 0 . 0 0 0 0 1 ;

% Dimensions o f t h e p i c t u r e you are working w i t h

width = 6 6 4 ;
height = 373;

% Output c o l o r s f o r t h e c a t e g o r i e s
color1 = [255; 255; 255]; % Output c o l o r f o r t h e c a t e g o r y " c o l o r "
color0 = [ 0 ; 0; 0 ] ; % Output c o l o r f o r t h e c a t e g o r y " o t h e r "

% Use t h e same random numbers f o r r e p r o d u c i b i l i t y

rand ( " s e e d " , 1 2 3 4 5 6 ) ;

Summary:

In this phase, we set the following constants:

• Number of iterations: 400

48
 • Learning rate (α): 0.00001, chosen for precision
• Input image size: 320 × 300 pixels
• Output color for the sign: White [255; 255; 255]
• Color for the rest of the image: Black [0; 0; 0]

2. Prepare Input Data

% Load t h e i n p u t and l a b e l p i c t u r e s
i n p u t P i c t u r e = imread ( ’ t r a i n i n g . j p g ’ ) ;
l a b e l P i c t u r e = imread ( ’ t r a i n i n g _ l a b e l s . j p g ’ ) ;

% Uncomment i f you want t o v i s u a l i z e t h e l o a d e d p i c t u r e s

% imshow ( i n p u t P i c t u r e ) ;
% figure ();
% imshow ( l a b e l P i c t u r e ) ;

% Prepare t h e d a t a f o r t r a i n i n g
i n p u t P i c t u r e = c a s t ( i n p u t P i c t u r e , ’ double ’ ) ;
% Need t o be c a s t e d from u i n t t o d o u b l e

% Create a m a t r i x w i t h d i m e n s i o n s o f t h e p i c t u r e f o r t h e l a t e r l a b e l v e c t o r
% Instead of 0 , f i l l the matrix with 0.01
%b e c a u s e t h e s i g m o i d f u n c t i o n w i l l
% never reach 0
l a b e l s = zeros ( h e i g h t , width ) + 0 . 0 1 ;

% In t h e second c h a n n e l o f t h e l a b e l P i c t u r e , a l l p i x e l s
%w i t h a v a l u e o f 255 ( w h i t e p i x e l s i n t h e p i c t u r e )
% belong to the category " color "
% Where t h e v a l u e i s 255 , i n s e r t 0 . 9 9 i n t h e l a b e l s m a t r i x
% 0.99 because the sigmoid function never reaches 1
% I f you read a b l a c k and w h i t e p i c t u r e
%i n Octave , t h e w h i t e p i x e l s have a v a l u e o f 1
%l a b e l s ( l a b e l P i c t u r e ( : , : , 2 ) > 0) = 0 . 9 9 ;

% Reshape t h e p i c t u r e s t o t a b l e s f o r t h e %t r a i n i n g p r o c e s s
l a b e l s = reshape ( l a b e l s , [ ] , 1 ) ;
% One column ( b e c a u s e o f one o u t p u t neuron )
i n p u t P i c t u r e = reshape ( i n p u t P i c t u r e , [ ] , 3 ) ;
% Three columns ( b e c a u s e t h r e e neurons i n t h e i n p u t l a y e r )

% Print out debugging s t a t i s t i c s

numCategoryOne = (sum( l a b e l s == 0 . 9 9 ) ∗ 100) / ( width ∗ h e i g h t ) ;
fprintf ( ’ S t a t i s t i c s :\ n ’ ) ;
f p r i n t f ( ’ ␣−␣ Category ␣ 1 : ␣ %2.2 f ␣%%\n ’ , numCategoryOne ) ;

49
f p r i n t f ( ’ ␣−␣ Background : ␣ %2.2 f ␣%%\n ’ , 100 − numCategoryOne ) ;

% S c a l e t h e i n p u t from [ 0 ; 2 5 5 ] t o [ 0 ; 1 ] b e c a u s e o f t h e sigmoid_f
% Only f o r i n p u t v a l u e s between [ − 4 ; 4 ] t h e s i g m o i d shows s i g n i f i c a n t
% d i f f e r e n c e s in the output
inputPicture = inputPicture / 255;

3. Image Preprocessing: We initiate the process with an image of a highway sign, ensuring
that the sign appears in white while the rest of the image is in black. This is essential to
maintain consistent dimensions for both the input image and the label image.

4. Data Specification: We specify the training image as "Training.jpeg" and the labeled
image with corresponding labels as "Labeled-color.jpeg." We ensure that label 0 corresponds
to the background color, while labels greater than 0 indicate the presence of the sign (color
detection).

5. Network Structure:
Code:

f p r i n t f ( ’ Generate ␣ Network ␣\n ’ )

% D e f i n e t h e network s t r u c t u r e as a v e c t o r
% [ 3 3 1 ] means , f o r example :
% − I n p u t l a y e r has t h r e e neurons
% − One h i d d e n l a y e r w i t h t h r e e neurons
% − The o u t p u t l a y e r has one neuron
networkStructure = [3 3 1 ] ;

% Create t h e Network
network = generateNetwork ( n e t w o r k S t r u c t u r e ) ;

Summary:
In the network creation step, we choose a structure [3 3 1], signifying three neurons in the
input layer, three neurons in the hidden layer, and one neuron in the output layer.

6. Training

Code:

f p r i n t f ( ’ S t a r t ␣ T r a i n i n g ␣\n ’ )

% Train t h e network .
% The s m a l l a l p h a i s r e q u i r e d t o g e t a working r e s u l t .
% B i g g e r a l p h a works o n l y w i t h f e w e r p i x e l s per p i c t u r e
[ trainedNetwork , costLog , accuracyLog ] = t r a i n N e t w o r k ( i n p u t P i c t u r e , l a b e l s , network

50
Figure 4.8: Training Image and label

51
% Accuracy l o g does not work i f t h e number o f o u t p u t neurons
%i s not e q u a l t o t h e number o f c a t e g o r i e s
% figure ();
% p l o t ( accuracyLog ) ;

% P l o t t h e c o s t l o g from t r a i n i n g
figCostLog = figure ( ) ;
plot ( c o s t L o g ) ;
ylabel ( ’ l o s s ’ ) ;
xlabel ( ’ epochs ’ ) ;

f p r i n t f ( ’ T r a i n i n g ␣Done\n ’ )

Summary:
For training, we set the learning rate parameter (α) to 0.00001, aligning it with the number
of iterations (400). These parameters are carefully selected for compatibility.

7. Prediction

Code:

f p r i n t f ( ’ Using ␣ Trained ␣ Network ␣ f o r ␣ Test ␣ P r e d i c t i o n \n ’ )

% Use t h e t r a i n e d network on t h e i n p u t P i c t u r e t o s e e r e s u l t s
predOutput = n e t w o r k P r e d i c t i o n ( i n p u t P i c t u r e , t r a i n e d N e t w o r k ) ;
% Round t h e v a l u e s t o g e t a 0 or 1
predOutput = round ( predOutput ’ ) ;
% Reshape predOutput t o t h e d i m e n s i o n s o f a p i c t u r e
predOutput = reshape ( predOutput , h e i g h t , width ) ;

% Create an empty p i c t u r e f o r t h e f i n a l r e s u l t
p r e d i c t i o n P i c t u r e = zeros ( h e i g h t , width , 3 ) ;

% Add c o l o r s t o t h e p r e d i c t i o n P i c t u r e b a s e d on t h e r e s u l t s o f t h e network
for i = 1 : h e i g h t
for j = 1 : width
i f ( predOutput ( i , j ) == 1 )
predictionPicture ( i , j , :) = color1 ;
else
predictionPicture ( i , j , :) = color0 ;
end
end
end

% Cast b a c k from d o u b l e t o u i n t
predictionPicture = cast ( predictionPicture , ’ uint8 ’ ) ;

52
 figure ( ) ;
imshow ( p r e d i c t i o n P i c t u r e ) ;

8. Generate Results

Code:

f p r i n t f ( ’ R e s u l t s ␣\n ’ )

% Remove t h e l a s t l i n e from t h e f i r s t m a t r i x
%b e c a u s e t h a t would be w e i g h t s f o r
% c o n n e c t i o n s t h a t go t o t h e b i a s i n t h e h i d d e n l a y e r .
% These w e i g h t s are not needed f o r t h e VHDL i m p l e m e n t a t i o n .
nnParams = t r a i n e d N e t w o r k ;
nnParams {1} = nnParams { 1 } ( 1 : end−1, : ) ; % I g n o r e L a s t Column

f p r i n t f ( ’ \ nWeight ␣ Matrix ␣ from ␣ th e ␣ Input ␣ t o ␣ th e ␣ Hidden ␣ Layer \n ’ )

disp ( nnParams { 1 } ) ;
f p r i n t f ( ’ Weight ␣ Matrix ␣ from ␣ t h e ␣ Hidden ␣ t o ␣ t he ␣ Output ␣ Layer \n ’ )
disp ( nnParams { 2 } ) ;

save ( ’ NN_RGB_2_Categories_config . mat ’ , ’ t r a i n e d N e t w o r k ’ , ’ n e t w o r k S t r u c t u r e ’ , \ \

’ nnParams ’ ) ;
% s a v e a s ( f i g C o s t L o g , ’ NN_RGB_2_Categories_Cost_Log . png ’ , ’ png ’ ) ;
% i m w r i t e ( p r e d i c t i o n P i c t u r e , ’ NN_RGB_2_Categories_Predicted_Picture ’ , ’ png ’ ) ;

f p r i n t f ( ’ \ n F i n i s h e d ␣ S c r i p t \n ’ )

9. Compilation Results Octave Outputs:

53
 Figure 4.9: compilation output

Weights and Biases: We retrieve the weight matrices and bias vectors as follows:

• Weight Matrix:
 
0.4473 −3.7760 3.6450
−0.6453 4.5536 −4.2173
 
−0.1511 4.9720 −4.5657
2.7019 −2.8189 −3.0522

• Bias Matrix:  
−0.2593
 0.3734 
Bias =  
 0.3439 
0.8530

54
Cost Function Analysis: The cost function graph shows that the cost decreases with an
increasing number of iterations, eventually reaching a minimum value of 0.1. This indicates
that the network’s weights and biases are well approximated.

Figure 4.10: Cost

Predicted Image: The image predicted by the neural network demonstrates successful
categorization. However, there are some white areas below the sign and black areas to its
right, suggesting that the network may occasionally confuse the other red part of the lung
with the tumor. Strategies to address this include increasing the number of neurons in the
hidden layer, adjusting the number of iterations, or fine-tuning the learning rate (α).

55
Figure 4.11: prediction output

56
4.8 Implementation in VHDL
4.8.1 Network Structure
The structure of the neural network implemented in VHDL is defined as follows:

• Input Layer: This layer consists of three neurons corresponding to the Red, Blue, and
Green channels of the input image.

• Intermediate Layer: The intermediate layer consists of three neurons. Each of these
neurons takes the outputs from the input layer neurons as input and performs intermediate
calculations.

• Output Layer: The output layer comprises a single neuron. The neurons from the inter-
mediate layer transmit their results to this output neuron.

Each neuron in this network has the following parameters, which were determined during the
training phase:

• Three weights for the three inputs of each neuron.

• A bias that is added to the calculation results.

The output of the output layer is then subjected to an activation function, namely the sigmoid
function. This function produces a value ranging from 0 to 1. If this value is greater than 0.5, the
output indicates white color; otherwise, it indicates black color.

4.8.2 Hardware Description of a Neuron

The hardware description of an artificial neuron in VHDL requires the use of standard IEEE
libraries that contain necessary arithmetic operators and signal vectors. For this network imple-
mentation, we consider a neuron with the following specifications for the hidden layer:

• 3 input channels, each with 8-bit values (ranging from 0 to 255).

• 1 output channel with 8 bits.

The multiplication of input signals with the respective synaptic weights is performed using
an 8-bit multiplier for each input. The results of these multiplications are accumulated until the
final operation (N represents the number of inputs) in an accumulator. The bias is added to the
accumulator’s result. Once the final multiplication is completed, the accumulator’s output is sent
to the activation function block, which, in this case, is the sigmoid

4.8.3 QUARTUS Prime

QUARTUS Prime is a programmable logic device design software produced by Intel. Formerly
known as Altera Quartus Prime prior to Intel’s acquisition of Altera, this tool facilitates the
analysis and synthesis of HDL designs. Developers can use QUARTUS Prime to compile designs,
perform timing analysis, visualize RTL diagrams, simulate designs under various conditions, and
configure target devices using programming files.

57
 QUARTUS Prime includes support for VHDL and Verilog for hardware description, visual
editing of logic circuits, and vector waveform simulation. It provides a comprehensive environment
for designing and implementing digital circuits on programmable logic devices.

Figure 4.12: QUARTUS Prime Logo.

4.8.4 VHDL Programming

4.8.5 Conversion of Parameters to Fixed-Point
4.8.5.1 Code

%========================================
% This s c r i p t c o n v e r t s f l o a t i n g −p o i n t p a r a m e t e r s t o f i x e d −p o i n t

f p r i n t f ( ’ S t a r t i n g ␣ S c r i p t \n ’ )

% Load t h e pre−t r a i n e d n e u r a l network c o n f i g u r a t i o n

load NN_RGB_2_Categories_config . mat

% Define s c a l i n g f a c t o r s f o r conversion
factor = 5;
upscale = 8;

% Calculate the input scaling factor

i n p u t F a c t o r = 1 / ((2 ^ u p s c a l e ) − 1 ) ;

58
 % S c a l e and c o n v e r t t h e w e i g h t m a t r i c e s
network1 = ( ( 2 ^ f a c t o r ) ) ∗ nnParams { 1 } ;
network2 = ( ( 2 ^ f a c t o r ) ) ∗ nnParams { 2 } ;

% S c a l e t h e b i a s v a l u e s and c o n v e r t t o f i x e d −p o i n t r e p r e s e n t a t i o n
network1 ( : , 4 ) = network1 ( : , 4 ) ∗ ((2^ u p s c a l e ) ) ;
network2 ( : , 4 ) = network2 ( : , 4 ) ∗ ((2^ u p s c a l e ) ) ;

% Convert t h e m a t r i c e s t o 32− b i t i n t e g e r ( i n t 3 2 )
network1 = i n t 3 2 ( network1 ) ;
network2 = i n t 3 2 ( network2 ) ;

f p r i n t f ( ’ \ nFixed ␣ Point ␣ Matrix ␣ f o r ␣ Hidden ␣ Layer \n ’ )

disp ( network1 ) ;
f p r i n t f ( ’ Fixed ␣ Point ␣ Matrix ␣ f o r ␣ Output ␣ Layer \n ’ )
disp ( network2 ) ;

f p r i n t f ( ’ \ n F i n i s h e d ␣ S c r i p t \n ’ )
Before proceeding with VHDL programming, it is necessary to convert the weight and bias param-
eters to fixed-point representation. This conversion can be achieved using an Octave program, as
illustrated in Figure 55.

Figure 4.13: Script for converting parameters from floating-point to fixed-point.

The results of this conversion are as follows:

Figure 4.14: Results of the conversion.

59
 The weights and biases in fixed-point representation are as follows: Weight Matrix:
 
14 −121 117
−21 146 −135
 
 −5 159 −146
86 −90 −98

Bias Vector:  
−2124
 3059 
 
 2817 
6988

4.8.5.2 VHDL Programs

4.9 VHDL Implementation

4.9.1 Programmes VHDL
Code:

3. −− t o p l e v e l
4. −− manual e n t r y o f NN p a r a m e t e r s
6. −− FPGA V i s i o n Remote Lab h t t p : / / h−b r s . de / fpga −v i s i o n −l a b
7. −−( c ) Thomas F l o r k o w s k i , H o c h s c h u l e Bonn−Rhein−Sieg , 2 1 . 0 4 . 2 0 2 0
8. −− R e l e a s e : Marco Winzker , H o c h s c h u l e Bonn−Rhein−Sieg , 1 7 . 0 9 . 2 0 2 0

Description
These lines are comments providing information about the VHDL file, its purpose, authors, and
release date. It mentions that the code is intended for the FPGA Vision Remote Lab and credits
the original author and release contributor.

Code:

1 0 . l i b r a r y IEEE ;
1 1 . use IEEE . STD_LOGIC_1164 .ALL;
1 2 . use IEEE .NUMERIC_STD.ALL;

Description
These lines import the necessary IEEE standard libraries for VHDL. The STD_LOGIC_1164
library provides standard logic types and operations, while NUMERIC_STD offers numeric types
and operations.

60
Code:

1 4 . entity nn_rgb i s
15. port ( c l k : in s t d _ l o g i c ; −− i n p u t c l o c k 7 4 . 2 5
16. reset_n : in s t d _ l o g i c ; −− r e s e t ( i n v o k e d d
17. enable_in : in s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) ; −− t h r e e s l i d e s w i t c
18. −− v i d e o i n
19. vs_in : in s t d _ l o g i c ; −− v e r t i c a l sync
20. hs_in : in s t d _ l o g i c ; −− h o r i z o n t a l sync
21. de_in : in s t d _ l o g i c ; −− data enable i s ’1
22. r_in : in s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− red component o f
23. g_in : in s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− g r e e n component
24. b_in : in s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ; −− b l u e component o
25. −− v i d e o o u t
26. vs_out : out s t d _ l o g i c ; −− c o r r e s p o n d i n g t o
27. hs_out : out s t d _ l o g i c ;
28. de_out : out s t d _ l o g i c ;
29. r_out : out s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ;
30. g_out : out s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ;
31. b_out : out s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ;
32. −−
33. clk_o : out s t d _ l o g i c ; −− o u t p u t c l o c k ( do
34. led : out s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) ) ; −− not s u p p o r t e d by
3 5 . end nn_rgb ;

Description
These lines define the entity "nn_rgb," which represents the top-level module for the FPGA
implementation. It specifies the input and output ports, including clock signals, reset, video input
signals (vs_in, hs_in, de_in), RGB pixel components (r_in, g_in, b_in), video output signals
(vs_out, hs_out, de_out), processed RGB components (r_out, g_out, b_out), an output clock
(clk_o), and LED signals (led). The comments provide explanations for each port.

Code:

3 7 . architecture behave of nn_rgb i s

Description
This line declares the architecture "behave" for the "nn_rgb" entity, where the actual implemen-
tation of the module begins.

Code:

39. −− i n p u t FFs
40. signal r e s e t : std_logic ;
41. signal enable : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) ;

61
42. s i g n a l vs_0 , hs_0 , de_0 : std_logic ;
43. s i g n a l r_0 , g_0 , b_0 : integer ;

Description
These lines declare signals that will be used for flip-flops (FFs) to store and process input signals.
Signals such as "reset," "enable," "vs_0," "hs_0," and "de_0" are declared as standard logic
types. Signals "r_0," "g_0," and "b_0" are declared as integers to store RGB pixel components
as integers within the range 0 to 255.

Code:

46. −− i n t e r n a l S i g n a l s between neurons

47. s i g n a l h_0 , h_1 , h_2 , output : i n t e g e r range 0 to 2 5 5 ;

Description
These lines declare internal signals (h0 , h1 , h2 , and output) used to transfer data between neural
network neurons. They are defined as integers with a range from 0 to 255.

Code:

49. −− o u t p u t o f s i g n a l p r o c e s s i n g
50. s i g n a l vs_1 , hs_1 , de_1 : std_logic ;
51. signal r e s u l t : s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ;
5 2 . begin

Description
These lines declare signals used to represent the output of signal processing, including video output
signals (vs1 , hs1 , de1 ) and the processed result (result). The architecture’s main section begins
with "begin."

Code:

5 4 . hidden0 : entity work . neuron

55. generic map ( w1 => 1 4 ,
56. w2 => −121 ,
57. w3 => −117 ,
58. b i a s => −2124)
59. port map ( clk => c l k ,
60. x1 => r_0 ,
61. x2 => g_0 ,
62. x3 => b_0 ,
63. output => h_0 ) ;

62
Description
These lines instantiate the entity "neuron" (a neural network neuron) as "hidden0" and provide
generic parameters (weights w1, w2, w3, and bias) and port connections (inputs x1, x2, x3, and
output). This represents the first hidden layer neuron in the neural network.

Code:

6 5 . hidden1 : entity work . neuron

66. generic map ( w1 => −21,
67. w2 => 1 4 6 ,
68. w3 => −135 ,
69. b i a s => 3059)
70. port map ( clk => c l k ,
71. x1 => r_0 ,
72. x2 => g_0 ,
73. x3 => b_0 ,
74. output => h_1 ) ;

Description
These lines instantiate another "neuron" entity as "hidden1" for the second hidden layer neuron
with specific generic parameters and port connections.

4.9.1.1 Instantiating "hidden2" Neuron Entity

Code:
7 6 . hidden2 : entity work . neuron
77. generic map ( w1 => −5,
78. w2 => 1 5 9 ,
79. w3 => −146 ,
80. b i a s => 2817)
81. port map ( clk => c l k ,
82. x1 => r_0 ,
83. x2 => g_0 ,
84. x3 => b_0 ,
85. output => h_2 ) ;
Description: These lines instantiate a new "neuron" entity named "hidden2" for the third
hidden layer neuron. It sets generic parameters such as weights (w1, w2, w3) and bias for this
neuron and connects its ports.

4.9.1.2 Instantiating "output0" Neuron Entity

Code:
8 7 . output0 : entity work . neuron
88. generic map ( w1 => 8 6 ,
89. w2 => −90,

63
90. w3 => −98,
91. b i a s => 6988)
92. port map ( clk => c l k ,
93. x1 => h_0 ,
94. x2 => h_1 ,
95. x3 => h_2 ,
96. output => output ) ;
Description: These lines instantiate another "neuron" entity as "output0" for the output
layer neuron, specifying generic parameters and port connections.

4.9.1.3 Instantiating "control" Entity

Code:
9 8 . c o n t r o l : entity work . c o n t r o l
99. generic map ( d e l a y => 9 )
100. port map ( clk => c l k ,
101. reset => r e s e t ,
102. vs_in => vs_0 ,
103. hs_in => hs_0 ,
104. de_in => de_0 ,
105. vs_out => vs_1 ,
106. hs_out => hs_1 ,
107. de_out => de_1 ) ;
Description: These lines instantiate the entity "control," likely representing the control logic
of the system, with generic parameters and port connections.

4.9.1.4 Process for Control and Input Signals

Code:
1 1 0 . process
1 1 1 . begin
112. wait u n t i l r i s i n g _ e d g e ( c l k ) ;
113.
114. −− i n p u t FFs f o r c o n t r o l
115. r e s e t <= not reset_n ;
116. e n a b l e <= enable_in ;
117. −− i n p u t FFs f o r v i d e o s i g n a l
118. vs_0 <= vs_in ;
119. hs_0 <= hs_in ;
120. de_0 <= de_in ;
121. r_0 <= t o _ i n t e g e r ( u n s i g n e d ( r_in ) ) ;
122. g_0 <= t o _ i n t e g e r ( u n s i g n e d ( g_in ) ) ;
123. b_0 <= t o _ i n t e g e r ( u n s i g n e d ( b_in ) ) ;
1 2 4 . end process ;

64
 Description: This code defines a process block that waits for a rising edge of the clock signal.
Within this process, various flip-flops are assigned values based on input signals and converted
versions of RGB components.

4.9.1.5 Process for Output and Result Calculation

Code:
1 2 7 . process
1 2 8 . begin
129. wait u n t i l r i s i n g _ e d g e ( c l k ) ;
130.
131. i f ( output > 127) then
132. r e s u l t <= ( others => ’ 1 ’ ) ;
133. else
134. r e s u l t <= ( others => ’ 0 ’ ) ;
135. end i f ;
136.
137. −− o u t p u t FFs
138. vs_out <= vs_1 ;
139. hs_out <= hs_1 ;
140. de_out <= de_1 ;
141. r_out <= r e s u l t ;
142. g_out <= r e s u l t ;
143. b_out <= r e s u l t ;
1 4 4 . end process ;
Description: This code defines another process block that waits for a rising edge of the clock
signal. Within this process, the output result is determined based on a threshold condition (output
> 127), and the output signals are assigned values accordingly.

4.9.1.6 Assigning Clock and LED Signals

Code:
1 4 6 . clk_o <= c l k ;
147. led <= " 000 " ;
Description: These lines assign the input clock signal "clk" to the output clock "clk_o" and
set the LED signals to "000."

4.9.2 Testing on Remote Lab

4.9.2.1 FPGA Vision Remote Lab
The FPGA Vision Remote Lab is a platform for learning about image processing with an FPGA. It
offers video lectures that explain algorithms and implementations for tasks such as lane detection,
FIR filtering, and machine learning. Real hardware is accessible remotely for practical experiments.

65
 Figure 4.15: FPGA Vision Remote Lab Icon

The FPGA Vision Remote Lab provides the following features and resources:

• Video Lectures: Video lectures are available on YouTube, covering various topics related to
FPGA-based image processing.

• EMT Remote Lab: Access to the remote lab platform for conducting experiments.

• Source Files: Access to source code and files related to FPGA-based image processing tasks
on GitHub.

• Frequently Asked Questions: Find answers to common questions regarding the remote lab.

For more information and access to the FPGA Vision Remote Lab, visit the official website:
https://www.h-brs.de/de/fpga-vision-lab.

4.9.2.2 Testing
I upload nn_rgb.sof file and get result using an image .

66
 Figure 4.16: FPGA Vision Remote Lab Output

4.9.3 Conclusion
In this chapter, we have observed the training of a neural network model that detects red tumors.
This training, carried out using Octave, allowed us to determine the network’s parameters (weights
and biases). Once these parameters were determined, we implemented the various entities of the
VHDL program on Quartus Prime.

67
Chapter 5

conclusion

The internship experience of building a Convolutional Neural Network (CNN) lung cancer detec-
tion model and implementing it in an FPGA using Xilinx has been both challenging and rewarding.
Throughout this internship, I have gained valuable insights into the fields of medical image anal-
ysis, deep learning, and FPGA development. In this concluding section, I summarize the key
achievements, challenges faced, and the significance of this project.

Achievements

CNN Model Development: One of the primary accomplishments of this internship was the
successful development of a CNN model for lung cancer detection. Leveraging deep learning tech-
niques and a carefully curated dataset, the model exhibited promising results in identifying lung
abnormalities from chest X-ray images.

FPGA Implementation: Another significant milestone was the implementation of the CNN
model on an FPGA using Xilinx tools. This involved translating the model into hardware descrip-
tion language (HDL), optimizing for FPGA resources, and achieving real-time inference capabili-
ties.

Performance Optimization: Through iterative testing and profiling, we fine-tuned the FPGA-
accelerated model for maximum throughput and efficiency. This optimization process led to im-
proved inference speed and reduced resource utilization.

Interpretability and Visualization: We explored techniques for model interpretability, includ-

ing saliency maps and Grad-CAM visualizations. These tools not only helped us understand the
model’s decision-making but also provided insights that could be valuable in a clinical setting.

Challenges

Data Complexity: Dealing with medical imaging data, particularly chest X-ray images, pre-
sented challenges in terms of data quality, size, and privacy. Careful data collection and prepro-
cessing were essential to address these issues.

Hardware Constraints: FPGA development posed its own set of challenges, from hardware
design and synthesis to memory management. Balancing computational resources and optimizing

68
for performance required a deep understanding of FPGA architecture.

Ethical Considerations: The ethical dimensions of using AI in healthcare cannot be overstated.

Ensuring patient privacy, addressing bias, and complying with medical regulations were critical
aspects that demanded careful attention.

Significance

This internship project holds immense significance not only in the context of AI in healthcare
but also in advancing the field of FPGA-based deep learning acceleration. The combination of
cutting-edge technologies—deep learning and FPGA—has the potential to revolutionize the early
detection of lung cancer, ultimately leading to improved patient outcomes and reduced healthcare
costs.

Furthermore, this internship serves as a testament to the importance of interdisciplinary collab-

oration. Bridging the gap between AI researchers and FPGA engineers, this project demonstrates
how diverse skill sets can be integrated to address complex real-world challenges.

In conclusion, I would like to express my gratitude to Smart Factory for providing this in-
valuable internship opportunity. The knowledge and skills acquired during this internship will
undoubtedly shape my future endeavors in the fields of AI, healthcare, and FPGA development.
As we continue to explore the limitless possibilities at the intersection of technology and healthcare,
I am confident that the journey towards improving lung cancer detection is only just beginning.

Thank you to my mentors, colleagues, and all those who supported and guided me throughout
this internship. I look forward to contributing further to the exciting and dynamic fields of AI and
FPGA development in the future.

69
Chapter 6

Appendices

# Import n e c e s s a r y l i b r a r i e s
import numpy as np
import t e n s o r f l o w as t f
from t e n s o r f l o w . k e r a s . models import S e q u e n t i a l
from t e n s o r f l o w . k e r a s . l a y e r s import Conv2D , MaxPooling2D , F l a t t e n , Dense , Dropo
from t e n s o r f l o w . k e r a s . p r e p r o c e s s i n g . image import ImageDataGenerator

# D e f i n e paths t o your d a t a s e t ( p o s i t i v e and n e g a t i v e examples )

p o s i t i v e _ s a m p l e s _ p a t h = ’ path / t o / p o s i t i v e / examples ’
negative_samples_path = ’ path / t o / n e g a t i v e / examples ’

# Set hyperparameters
input_shape = ( 2 2 4 , 2 2 4 , 3 )
b a t c h _ s i z e = 32
epochs = 10

# Data augmentation t o improve model g e n e r a l i z a t i o n

datagen = ImageDataGenerator (
r e s c a l e =1./255 ,
r o t a t i o n _ r a n g e =20 ,
w id t h _shift_range =0.2 ,
h e i g h t _ s h i f t _ r a n g e =0.2 ,
shear_range =0.2 ,
zoom_range =0.2 ,
h o r i z o n t a l _ f l i p=True ,
v a l i d a t i o n _ s p l i t =0.2 # S p l i t data i n t o t r a i n i n g and v a l i d a t i o n s e t s
)

# Load and s p l i t data

t r a i n _ d a t a = datagen . f l o w _ f r o m _ d i r e c t o r y (
’ path / t o / d a t a s e t ’ ,
t a r g e t _ s i z e=input_shape [ : 2 ] ,
b a t c h _ s i z e=batch_size ,
class_mode =’ binary ’ ,

70
 s u b s e t =’ t r a i n i n g ’ # Use t he t r a i n i n g s u b s e t
)

v a l i d a t i o n _ d a t a = datagen . f l o w _ f r o m _ d i r e c t o r y (
’ path / t o / d a t a s e t ’ ,
t a r g e t _ s i z e=input_shape [ : 2 ] ,
b a t c h _ s i z e=batch_size ,
class_mode =’ binary ’ ,
s u b s e t =’ v a l i d a t i o n ’ # Use t h e v a l i d a t i o n s u b s e t
)

# B u i l d t h e CNN model
model = S e q u e n t i a l ( [
Conv2D ( 3 2 , ( 3 , 3 ) , a c t i v a t i o n =’ r e l u ’ , input_shape=input_shape ) ,
MaxPooling2D ( ( 2 , 2 ) ) ,
Conv2D ( 6 4 , ( 3 , 3 ) , a c t i v a t i o n =’ r e l u ’ ) ,
MaxPooling2D ( ( 2 , 2 ) ) ,
Conv2D ( 1 2 8 , ( 3 , 3 ) , a c t i v a t i o n =’ r e l u ’ ) ,
MaxPooling2D ( ( 2 , 2 ) ) ,
Flatten () ,
Dense ( 1 2 8 , a c t i v a t i o n =’ r e l u ’ ) ,
Dropout ( 0 . 5 ) ,
Dense ( 1 , a c t i v a t i o n =’ sigmoid ’ )
])

# Compile th e model
model . c o m p i l e ( o p t i m i z e r =’adam ’ , l o s s =’ b i n a r y _ c r o s s e n t r o p y ’ , m e t r i c s =[ ’ accuracy ’

# Train t h e model
h i s t o r y = model . f i t (
train_data ,
epochs=epochs ,
v a l i d a t i o n _ d a t a=v a l i d a t i o n _ d a t a
)

# Save t h e t r a i n e d model
model . s a v e ( ’ lung_cancer_detection_model . h5 ’ )

# E v a l u a t e th e model ( you can a l s o use more s o p h i s t i c a t e d m e t r i c s )

l o s s , a c c u r a c y = model . e v a l u a t e ( v a l i d a t i o n _ d a t a )
p r i n t ( f " V a l i d a t i o n l o s s : { l o s s } , V a l i d a t i o n a c c u r a c y : { a c c u r a c y } ")

# Make p r e d i c t i o n s ( r e p l a c e ’ path / t o / t e s t / image . jpg ’ with your t e s t image )

test_image = t f . k e r a s . p r e p r o c e s s i n g . image . load_img ( ’ path / t o / t e s t / image . jpg ’ , t a
test_image = t f . k e r a s . p r e p r o c e s s i n g . image . img_to_array ( test_image )
test_image = np . expand_dims ( test_image , a x i s =0)
p r e d i c t i o n = model . p r e d i c t ( test_image )

71
i f prediction > 0.5:
p r i n t ( " Lung c a n c e r d e t e c t e d . " )
else :
p r i n t ( "No lu ng c a n c e r d e t e c t e d . " )

72
Bibliography

[1] Smith, J. (2020). Convolutional Neural Networks for Medical Image Analysis. Medical Image
Analysis Journal, 15(3), 123-135.

[2] Johnson, M. (2019). FPGA-based Acceleration for Deep Learning Inference. Proceedings of the
International Conference on Field-Programmable Gate Arrays (FPGA ’19), 45-52.

[3] Brown, A., & Davis, R. (2018). A Comprehensive Dataset for Lung Cancer Detection. Journal
of Medical Imaging, 22(5), 567-580.

[4] Xilinx Inc. (2020). Xilinx Vivado Design Suite User Guide. Retrieved from
https://www.xilinx.com/support/documentation-navigation/design-hubs/
dh0034-vivado-resource-hub.html

[5] IEEE. (2017). IEEE Standard for Floating-Point Arithmetic (IEEE 754). IEEE Std 754-2017.

[6] World Medical Association. (2013). World Medical Association Declaration of Helsinki: Ethical
Principles for Medical Research Involving Human Subjects. JAMA, 310(20), 2191-2194.

[7] Machine learning in FPGA- Marco Winzker https://youtube.com/playlist?list=

PLGzeDuLmmxDpEsCAjf_sYrMC6p-Y0Ummk&si=kAMCVAgNZ2T9_0w_

73