text:
\documentclass[journal, a4paper]{IEEEtran}

\usepackage[left=2cm,right=1.5cm,top=1.5cm,bottom=1.5cm]{geometry}
\usepackage[backend=biber,sorting=ynt,style=alphabetic]{biblatex}
\usepackage[caption=false, font=normalsize, labelfont=sf, textfont=sf]{subfig}
\usepackage{graphicx}
\usepackage[utf8]{inputenc}
\usepackage[english]{babel}
\usepackage{csquotes}
\usepackage[parfill]{parskip}
\usepackage{url}
\usepackage{hyperref}
\usepackage{authblk}
\usepackage{graphicx}
\usepackage{amsmath}
\usepackage{lipsum}

\addbibresource{references.bib}

\graphicspath{{./images/}}

\hypersetup{
  colorlinks = true,
  linkcolor = blue,
  citecolor= blue,
  filecolor = blue,
  urlcolor = blue,
  pdftitle = {Pedestrian Semaphore Classification - An Active Learning Approach}
  pdfauthor = {Miguel Rabuge, Gabriel Fernandes, Pedro Rodrigues},
  pdfsubject = {Pedestrian Semaphore Classification},
  pdfkeywords = {Artificial Intelligence, Machine Learning, Active Learning,
  Autonomous Pedestrian Module, Image Classification},
  pdfproducer = {Latex with hyperref},
  pdfcreator = {pdflatex},
}

\begin{document}

\title{Pedestrian Semaphore Classification \\ An Active Learning Approach}
\author[1]{Gabriel Fernandes}
\author[2]{Miguel Rabuge}
\author[3]{Pedro Rodrigues}

\affil[1,2,3]{Department of Informatics Engineering, University of Coimbra, Portugal}{
  \makeatletter
  \renewcommand\AB@affilsepx{: \protect\Affilfont}
  \makeatother

  \makeatletter
  \renewcommand\AB@affilsepx{, \protect\Affilfont}
  \makeatother

  \affil[1]{gabrielf@student.dei.uc.pt}
  \affil[2]{rabuge@student.dei.uc.pt}
  \affil[3]{pedror@student.dei.uc.pt}
}

\maketitle

\thispagestyle{plain}
\pagestyle{plain}

\begin{abstract}

The environments, in which pedestrians with some form of disability circulate are
often extremely risky, more so than for "healthy" pedestrians. Not only the
environments are dynamic, and full of uncertainty but, since an impaired
individual is not able to record quality sensory information his ability to
navigate through the environment, without endangering himself, is compromised.
The most common solution for this problem is some form of personal companion,
e.g “a guide dog”, that helps the individual circulate. Training these kinds of
companions is often slow and expensive... We propose an “Active Learning” (AL)
approach for training a classifier that could be integrated in an artificial
personal companion module. In our work, we go on to compare our AL methodology
not only with state of the art models, but also with a model reported in recent paper
on this topic. The obtained results show that models trained using this
methodology can obtain the similar accuracies and with less data required.

\end{abstract}

\begin{IEEEkeywords}

Artificial Intelligence, Machine Learning, Active Learning, Autonomous Pedestrian Module,
Image Classification.

\end{IEEEkeywords}

\section{Introduction}

Nowadays, there is a lot of effort being put into solving the problem of
autonomous driving, not only because of research but also because of the security
and comfort that autonomous vehicles may bring to our lives. Despite the fact of
this problem being hard, it is made easy because of the environment
where the action of driving happens. There is a set of rules about how to drive,
and where to drive to avoid potential accidents resulting in collisions with
other vehicles, persons or objects. In other words, the environment is dynamic
and risky, but it is less chaotic and more well-defined than others, which becomes
more suited for the development of artificial intelligence approaches for training
vehicles to be autonomous.

To our knowledge, there has not been a lot of development of similar techniques
for pedestrians, namely the ones that show some form of disability that could put
them in danger if not accompanied by some form of personal companion. The
pedestrian environment, unlike the one where vehicles circulate, does not have a
set of rules describing the way people should walk nor a place where the action of
walking takes place. The pedestrian may be forced to walk on a sidewalk, a
(lighted) crosswalk, in rugged terrain or even in the car lane if no sidewalk
exists. Additionally, the objects that a pedestrian needs to avoid obviously
increases since a person needs not to worry only about walking itself, but also
other obstacles with more unpredictable moving patterns. Therefore, the
environment is often so chaotic that travelling by foot requires assistance and
makes the problem less approachable from an artificial intelligence standpoint.

Since the problem of autonomous mobility for disabled pedestrians is not
particularly developed, and the only way such mobility can be achieved is with
the help of some form of companion, (like for instance a guide dog which requires
a lot of training to successfully guide people), our contribution is to advance
inside this field in terms of pedestrian semaphore detection and classification
for a crosswalk-taking decision. The choice of an active learning (AL) approach
is justified by the lack of datasets for this specific task. Therefore, AL is the
perfect methodology to apply for this niche, but yet significant, application,
since it can extract better accuracy from the models with fewer data.

In short, with this project we aim to explore an alternative methodology for
this problem, by comparing the State-of-the-Art methods performance with our own,
using various metrics. Our main objective is to build a classifier that should be
fast to classify and highly accurate, without the need for large amounts of data.

We will base our research of a late breaking work entitled - "Flying Guide Dog:
Walkable Drones and Transformer-based Semantic Segmentation" \cite{tan2021flying}
- that uses a custom-made classification model based on a convolutional neural
network (CNN) for semaphore detection on segmented images. Moreover, not only
will we test our AL approach against this paper's CNN model, but we will build
and train other State-of-the-Art CNN's in order to further study and justify
the possibility of an AL approach to yield more efficient results.

\section{State Of The Art} \label{sota}

In the past few years, the State of the Art of image classifiers tends to revolve
around Convolutional Neural Networks, due to the large amounts of data and
the processing power currently available, which have turned out to be highly
rewarding when both conditions are true. Although the hardware available today
is really sophisticated and allows us to achieve good results through the use
of CNN's for image recognition.

Regarding Active Learning, this approach aims to iteratively find the most
informative data points to train the model, through the use of impurity measures.
This methodology reveals being highly rewarding, generating good models with low
data usage.

In the next sections we will discuss the state of the art convolutional neural
networks, focusing our analysis on the ``LeNet-5'' \cite{LeNet-5} and
``AlexNet'' \cite{AlexNet} deep neural networks that we use later in work
as a base for comparison and benchmark. We also refer the Active Learning
methodology and point out some known strategies used with this method that
we will also take advantage of in our experimental phase.

\subsection{Convolutional Neural Networks (CNN's)}

For the last years, deep learning has become a hot topic in the Artificial
Intelligence landscape, with convolutional neural networks being one
of the most widely used methods for image classification, natural language
processing and computer vision tasks. Prior to this other methods were used
that relied on slow and time-consuming feature extraction methods, that
with CNN's are not necessary since they are able to work with raw image data
without any need for feature pre-processing, therefore being perfect at picking up
small patterns, which then are ``processed'' and combined through the multiple
layers of the network, until the model can make sense of the provided data
and classify what a given object really is.

Convolutional Neural Networks pose a great advantage in image classification, relying mainly on
mathematical and algebraic models. In fact, many of the operations performed inside
the multiple layers of these deep networks often involve matrix multiplications
and other calculations that are highly vectorizable and parallelizable.
The main drawbacks are that they are computationally demanding, often
requiring graphical processing units (GPUs) for training more complex models
and usually take some time to be trained to a level that make them efficient
and accurate. In brief, by using CNN's the time and effort shifts from the
user to the machine which somewhat advantageous, with the processing power
we have available to us nowadays.

The architecture of a CNN is mainly based on a multi-layer feed forward network
comprised of layers that learn from features processed by the layers before.
The layers of these networks belong to one of these three types: convolutional,
fully connected and pooling, existing many possible architectures made from
arranging these in meaningful way.

\begin{figure}[htpb]
    \centering
    \includegraphics[scale=0.30]{LeNet-5}
    \caption[CNN]{Example architecture of a convolutional neural network
      (LeNet-5); image from \parencite{LeNet-5}}
    \label{cnn}
\end{figure}

One well known attempt on CNN design was done by \textbf{Yann LeCun} with
the self-titled LeNet-5 \cite{LeNet-5}, which is known to have good performance in handwritten
digit recognition (MNIST) dataset and is still to this day considered a reference.
Overall this CNN consists on a five layer architecture that at a very high level
is composed of two convolutional layers that serve as an encoder, and three
fully connected layers that belong to the dense block of the network.
A more recent attempt on a CNN design developed by \textbf{Alex Krizhevsky, Ilya Sutskever,
and Geoffrey E. Hinton.}, the ``AlexNet'' \cite{AlexNet}. The CNN consists on an implementation
on the LeNet-5 \cite{LeNet-5} but much deeper, having a total number of layers that amount to
eight. Architecturally, the first five layers consist of convolutional layers (oftentimes
appearing interleaved with pooling layers) and the last three are fully connected layers.

These CNN designs have proven to have good performance and have been considered state of the art
although other designs may be more effective for different datasets. For instance, on the
``Pedestrian and Vehicle Traffic Lights'' (PVTL) dataset \cite{PVTL} the authors used their own
implementation of a simple CNN (5 convolutional layers + 3 fully connected layers), claiming that
it was able to achieve 83\% accuracy; furthermore, by using  a fine tuned CNN based on the
``ResNet'', another state of the art CNN provided in the \textit{keras} python library, they
were able to obtain accuracies of 90\%, both over a 25 epochs training.

Overall the results obtained by using state of the art CNN based models for image
classification are promising and, when properly tuned, tend to be even better suited for
each specific need. Our aim, with our work, is to further explore other possibilities for
improving these models through the use of other techniques, such as active learning.

\subsection{Active Learning}

On active learning \textbf{Burr Settles} \cite{settles.tr09, pmlr-v16-settles11a} describes
it as being a method for further improving the performance of machine learning models, making
them achieve greater accuracies. In this semi-supervised learning method, through the usage of
queries of unlabeled data made to an \textit{oracle}, the active learner is not only able to
choose the data from which it learns but also choose the data where the model is most
uncertain about and learn from it, therefore increasing the learning process speed.

The active learning cycle is a sequence of steps by which an active learner attempts
to iteratively improve the performance of the model. One of the most common active leaning
cycle methodologies is the pool-based sampling active learning, in which the queries made to
the \textit{oracle} select examples from a ``pool'' of  unlabeled instances in accordance
to a given strategy that should take into account the information gain that a given instance
may add to the model.

\begin{figure}[htpb]
    \centering
    \includegraphics[scale=0.38]{AL}
    \caption[AL]{A pool-based active learning cycle; image from \parencite{settles.tr09}}
    \label{al}
\end{figure}

There exists a wide variety of query strategies, namely: query-by-committee, expected model change,
expected error reduction, uncertainty sampling, etc... .One of the most commonly used query
strategies, and that we will use in the experimental phase of our work is
\textit{uncertainty sampling} and consists in a framework where the queries to the model, made by
the active learner, are done in such a way as to select the instances from the pool which the
learner is \textit{less confident} about (\ref{eq:1}). The standard measure of uncertainty used
by this method consists in the choice of the instance whose prediction conveys the
lowest confidence. Other measures often considered are the \textit{entropy} (\ref{eq:2})
and the probability difference between the two most likely labels (\ref{eq:3}); these
strategies correspond to the so called \textit{entropy sampling} and \textit{margin sampling}
strategies respectively.

\begin{equation}
    \label{eq:1}
    \large{x^*_{LC} = \operatorname*{argmax}_x 1
                       - P_{\theta}(\hat{y}_{1}|x)}
\end{equation}

\begin{equation}
    \label{eq:2}
    \large{x^*_{H} = \operatorname*{argmax}_x
                   \sum_{i}{P_{\theta}(y_{i}|x)
                   \cdot
                   \log{P_{\theta}(y_{i}|x)}}}
\end{equation}

\begin{equation}
    \label{eq:3}
    \large{x^*_{M} = \operatorname*{argmin}_x
                    P_{\theta}(\hat{y}_{1}|x)
                    - P_{\theta}(\hat{y}_{2}|x)}
\end{equation}

Above are shown in mathematical notation the possible metrics for picking an instance under the
\textit{uncertainty sampling} active learning framework. In the formulas above, $\theta$ represents
the model and $x$, $y$ instance labels. For formulas (\ref{eq:1}, \ref{eq:3}),
$\hat{y}_{k}=\operatorname*{argmax}_y P_{\theta}(y|x)$ denotes the $k$-th most probable
instance label under the model $\theta$. \cite{settles.tr09}.

Having discussed the state of the art active learning methodologies we will now move on to the
experimental phase of our work where we will put these methods in practice and check if we can
extract any benefits of their usage.

\section{Materials: Datasets and Frameworks}

In terms of pedestrian assistive agents, there has not been a lot of research
related to it since a ``Pedestrian Assistant'' is a relatively recent topic.
The most recent scientific paper that we found for it, uses a standard
state of the art CNN for the pedestrian traffic lights detection and
classification module of their project, trained by using a newly introduced
dataset “Pedestrian and Vehicle Traffic Lights” (PVTL), \cite{PVTL} which is a
preprocessed subset of \href{https://www.mapillary.com/}{Mapillary’s} vast image data
set that we are going to make use throughout our work.

\begin{figure}[htpb]
    \centering
    \includegraphics[scale=0.28]{PVTL-Preview}
    \caption[PVTLD]{Pedestrian Vehicle and Traffic Lights dataset sample;
                    image from \parencite{PVTL}}
    \label{pvtld}
\end{figure}

This dataset is composed by a series of images of semaphores of different types, colors
and shapes. The data in this dataset is grouped into five different classes:
``Others'', ``Pedestrian-green'', ''Pedestrian-red'', ``Vehicle-red'', ``Vehicle-green''.
The image above (figure \ref{pvtld}) illustrates the different dataset classes and shows
some samples of images that may be found in each class. Each one of these classes contains about
300 images that we preprocessed in order to standardize the input. The image preprocessing step
will be discussed in the ``Dataset Preprocessing'' section \ref{dpp}.

The whole project was developed using the python programming language and making use
of multiple python frameworks that provided us with tools for image processing, deep neural network
model construction/training and active learning. A list of frameworks used in our work can
be consulted in the ``Frameworks'' section \ref{frmw}.

For consistency and reproducibility purposes all experiments were made in a single machine
whose specifications are shown in the table below.

% TODO: Maybe complete with more detailed specs?
\begin{table}[h]
    \label{tab:1}
    \caption{Benchmark Machine specifications.}
    \centering
    \scalebox{1.25}{
        \begin{tabular}{|l|l|}
            \hline
            CPU & AMD Ryzen™ 7 1700 Processor 3.0GHz \\ \hline
            RAM & 16GB DDR4                          \\ \hline
            GPU & Nvidia GeForce 1070                \\ \hline
        \end{tabular}
    }
\end{table}

\subsection{Dataset Preprocessing} \label{dpp}

In order to make the images from the \cite{PVTL} dataset ready to be used the models
developed, we needed to address the fact that all the images had different dimensions.
This fact made it unfeasible to feed the images as is directly to a CNN and
required us to reshape all the images in dataset. After a careful look
at the dataset, we decided that we would work with images with dimensions 224x224 pixels and
proceeded to proportionally re-scale all the images to said dimensions. In the case of the images
which a re-scaling event would result in the image being shrunk down, the regions left empty
were filled with a black strip, therefore minimizing any interference in the model's predictions.

\subsection{Frameworks} \label{frmw}

In terms of frameworks, in this project besides all the standard python libraries, we used
the following frameworks:

\begin{itemize}
    \item \textbf{Pillow} \cite{PIL}: For loading the dataset images.
    \item \textbf{TensorFlow} \cite{tensorflow}: For CNN model construction.
    \item \textbf{modAL} \cite{modAL}: For the AL cycle implementation.
    \item \textbf{openCV} \cite{openCV}: For image preprocessing (e.g re-scalling/padding).
\end{itemize}

\section{Experimental Setup}

In this section we present the experimental setup for studying the effectiveness/performance of
and active learning approach on pedestrian semaphore classification. In the first sub-section
\ref{impl} we discuss the implementation made in the scope of this project and in the second
\ref{exp} we move on to talk about the design of the experiments / experimental scenario.

\subsection{Implementation} \label{impl}

% TODO: check the writing on this section please!

For the purposes of work and in order to implement the active learning cycle we needed
well designed models that would allow us to observe the active learning contribution.

First of all, we started by implementing some state of the art CNN's since these are
well known models and have proved to yield a good performance in image classification,
therefore serving as the control group of our experiments. That being said,
the state of the art CNN's we ended up choosing for implementation were
LeNet \cite{LeNet-5} and the AlexNet \cite{AlexNet} whereas both are similar but
architecturally one CNN has more depth than the other.

Afterwards, in order to later establish further comparison with the most recent
work (to our knowledge) on personal companions for impaired pedestrians \cite{tan2021flying},
we decided to implement one of the CNN's used in said work. With this, our main goal was not
only compare the performance with state of the art CNN's (control group), but also later
check if the AL approach would better the performance obtained by this CNN that was
custom built for this particular problem. The architecture of the CNN as previously
discussed in the state of the art section (\ref{sota}), that at a very high level,
is comprised of 5 convolutional layers followed by 3 fully connected layers.
Throughout our work we will refer back to this CNN as \textit{FlyNet}.

After the models were implemented it was time to introduce the active learning cycle
into the models. For this work we decided to use uncertainty based sampling, implementing
the multiple sampling strategies in order to assess which one was the best fit for our goals.

\subsection{Experimental Scenario} \label{exp}

Having the dataset loaded and all the necessary components of the AI system implemented we
proceeded to testing it. The experiences conducted were designed to test the multiple models
implemented as well as how they behaved when the active learning loop was introduced. Be that
as it may, we ran each CNN model with 30 different seeds (from seed with number 0 to 29) with a
training duration of 25 epochs, hence obtaining representative results of the performance of the
CNN and avoiding a potential bias that running with the same seed might have introduced. The choice
for 25 epochs training duration was due to the accuracy stabilization observed after 15 epochs,
also in the \cite{tan2021flying} paper they used the same parametrization which inclined towards us
using this value.

\begin{figure}[htpb]
    \centering
    \includegraphics[scale=0.4]{CNNAccuracy}
    \caption[CNNAcc]{Accuracy evolution over 25 epochs for the multiple CNN's;
        training set results; seed 42.}
    \label{CNNAcc}
\end{figure}

Afterwards, we tested the active learning loop on each of the trained models using the
multiple query strategies implemented (\ref{impl}). As the parametrization of the the AL loop,
we used an initial size of the training data of 600 known labels, a query size of 60 labels and,
as the maximum number of queries made in the active learning loop, 11 queries, having concluded
a total of 8 queries per learning strategy until the pool of unlabeled data was depleted.
Furthermore, after each query, the model was re-trained with 25 epochs in order to
be able to learn the new examples provided. Last but not least, on the experiments made the
considered metric was the accuracy obtained by the model using AL when compared
with the model without it. Our main interest is to observe the impact in terms of performance
(accuracy) and its evolution, e.g number of queries needed to obtain results the match the original model
without the AL cycle.

\section{Results}

We started by looking at the performance of the models when considering the raw models without
the active cycle implemented into it. The results obtained can be observed in the following table:

\begin{table}[htpb]
    \centering
    \caption{Average CNN's accuracy over 30 runs (test set)}
    \scalebox{1.25}{
        \begin{tabular}{|c|c|}
            \hline
            CNN                       & Accuracy        \\ \hline
            LeNet5                    & 0.809           \\ \hline
            AlexNet                   & 0.868           \\ \hline
            FlyNet                    & 0.417           \\ \hline
        \end{tabular}
    }
    \label{tab:2}
\end{table}

The results (table \ref{tab:2}) show that both LeNet5 and AlexNet show good performances on
the testing set, unfortunately the FlyNet network implementation performs poorly, which
is something unfortunate taking into account the accuracy reported by the authors of the
CNN \cite{tan2021flying} on their tests. These results on the FlyNet may be
implementation dependent but the original authors do not provide any details about that so
we can reproduce their work, leaving us to establish our analysis
strictly with our implementation which yields this performance. Nonetheless, the results may
still be used to assess the quality of the AL methodology we wish to test.

In the following graphics we show the comparison between the performances obtained when
comparing the results obtained from running, on the test set, the raw CNN's against the
results obtained when the AL cycle (with multiple query strategies) was introduced
(figure \ref{ALP1}). We also show the results obtained when comparing the performances
obtained by the CNN's with AL, in the training set against the ones obtained in the testing set (figure \ref{ALP2}).

\begin{figure*}[htpb]
    \centering
    \subfloat[LeNet5\label{1a}]{
       \includegraphics[scale=0.4]{LeNet5_VS_AL.png}
    }
    \hfill
    \subfloat[AlexNet\label{1b}]{
        \includegraphics[scale=0.4]{AlexNet_VS_AL.png}
    }
    \hfill
    \subfloat[FlyNet\label{1c}]{
        \includegraphics[scale=0.4]{FlyNet_VS_AL.png}
    }
    \caption{Performance evolution for the CNN's: LeNet5 (figure \ref{1a}), AlexNet (figure
    \ref{1b}), FlyNet (figure \ref{1c}), compared with CNN's + AL with different query
    strategies (entropy sampling (blue), margin sampling (green), least confidence (red) sampling).}
    \label{ALP1}
\end{figure*}

\begin{figure*}[htpb]
    \centering
    \subfloat[LeNet5\label{2a}]{
       \includegraphics[scale=0.4]{LeNet5_TT_AL.png}
    }
    \hfill
    \subfloat[AlexNet\label{2b}]{
        \includegraphics[scale=0.4]{AlexNet_TT_AL.png}
    }
    \hfill
    \subfloat[FlyNet\label{2c}]{
        \includegraphics[scale=0.4]{FlyNet_TT_AL.png}
    }
    \caption{Performance evolution and differences between training and testing sets for the
    CNN's + AL: LeNet5 (figure \ref{2a}), AlexNet (figure \ref{2b}), FlyNet (figure \ref{2c}),
    with different query strategies (entropy sampling (blue),
    margin sampling (green), least confidence (red) sampling)}
    \label{ALP2}
\end{figure*}

\section{Discussion and Conclusions}

As we can observe from the results we obtained, in general the accuracies we got from using
the CNN's with AL are very close to the ones obtained when using the raw CNN's with no AL,
using a smaller amount of instances. This is visible on the multiple plots on figure \ref{ALP1}.

When comparing the performance difference
between the training set and the testing sets, figure \ref{ALP2}, we can see that the results
obtained are worse when we look at the test set in comparison to the training set. This is
to be expected since the testing set contains data that the model has never seen,
which leads it to have less accuracy. Nonetheless, the accuracy difference between training/test
sets for the AlexNet and FlyNet CNN's is not blatant, showing that these models have great
generalization capabilities, therefore being able to classify new samples accurately.
In the case of the LeNet5, the results show that this CNN's is most certainly overfiting on
the training data. This is evident since, with the training set the model is able to obtain
accuracies that round 1.0, but when it is exposed to the test set it is only able to reach
accuracies of about 0.80.

In conclusion, we are confident that the results obtained are representative of the improvements
that an AL approach for training classifiers may bring, in the sense that we can train the
models with less data. When comparing to state of the art methods, and the model in the \cite{tan2021flying} paper, results also show that this methodology is really competitive.

\section{Future Work}

From our research, we realized that there is still a lot to be done in this field.
In fact, the development of assistive systems for impaired pedestrians is a fairly
recent topic from the point of view of AI research, much so that with our work, we only
touched a small topic which is the improvement of semaphore classification techniques
for these systems by using active learning techniques. We feel that two main things must
be done in the near future in order to enable more research in this area. First of all
the creation of more datasets containing a wider variety of obstacles that a pedestrian may
encounter is of paramount importance. The existence of more datasets will allow the
same methodology discussed in this work to be used in the classification of more objects,
therefore allowing for the development of a more capable and complete assistive systems.
Last but not least, regarding our work in particular, the experimentation with other active
learning query strategies is an important topic that we leave as future work, as other
methodologies may be able to achieve even better results.

\printbibliography

\end{document}

max_stars_repo_name: MikeLrUC/IA-Project

max_issues_repo_name: MikeLrUC/IA-Project

max_forks_repo_name: MikeLrUC/IA-Project


text:
%-------------------------
% Resume in LaTeX
% Author : Simon Chase
% Based off of: https://github.com/sb2nov/resume
% License : MIT
%------------------------

% SETUP {
\documentclass[letterpaper,11pt]{article}

\usepackage{latexsym}
\usepackage[empty]{fullpage}
\usepackage{titlesec}
\usepackage{marvosym}
\usepackage[usenames,dvipsnames]{color}
\usepackage{verbatim}
\usepackage{enumitem}
\usepackage[hidelinks]{hyperref}
\usepackage{fancyhdr}
\usepackage[english]{babel}
\usepackage{tabularx}
\usepackage{ulem}
\input{glyphtounicode}

\pagestyle{fancy}
\fancyhf{} % clear all header and footer fields
\fancyfoot{}
\renewcommand{\headrulewidth}{0pt}
\renewcommand{\footrulewidth}{0pt}

% Adjust margins
\addtolength{\oddsidemargin}{-0.5in}
\addtolength{\evensidemargin}{-0.5in}
\addtolength{\textwidth}{1in}
\addtolength{\topmargin}{-.5in}
\addtolength{\textheight}{1.0in}

\urlstyle{same}

\raggedbottom
\raggedright
\setlength{\tabcolsep}{0in}

% Sections formatting
\titleformat{\section}{\vspace{-4pt}\scshape\raggedright\large}{}{0em}{}[\color{black}\titlerule \vspace{-5pt}]

% Ensure that generate pdf is machine readable/ATS parsable
\pdfgentounicode=1

%-------------------------
% Custom commands
\newcommand{\resumeItem}[1]{
	\item\small{
		{#1 \vspace{-2pt}}
	}
}

\newcommand{\resumeSubheading}[4]{
	\vspace{-2pt}\item
		\begin{tabular*}{0.97\textwidth}[t]{l@{\extracolsep{\fill}}r}
			\textbf{#1} & #2 \\
			\textit{\small#3} & \textit{\small #4} \\
		\end{tabular*}\vspace{-7pt}
}

\newcommand{\resumeSubSubheading}[2]{
    \item
    \begin{tabular*}{0.97\textwidth}{l@{\extracolsep{\fill}}r}
      \textit{\small#1} & \textit{\small #2} \\
    \end{tabular*}\vspace{-7pt}
}

\newcommand{\resumeProjectHeading}[2]{
    \item
    \begin{tabular*}{0.97\textwidth}{l@{\extracolsep{\fill}}r}
      \small#1 & #2 \\
    \end{tabular*}\vspace{-7pt}
}

\newcommand{\resumeSubItem}[1]{\resumeItem{#1}\vspace{-4pt}}

\renewcommand\labelitemii{$\vcenter{\hbox{\tiny$\bullet$}}$}

\newcommand{\resumeSubHeadingListStart}{\begin{itemize}[leftmargin=0.15in, label={}]}
\newcommand{\resumeSubHeadingListEnd}{\end{itemize}}
\newcommand{\resumeItemListStart}{\begin{itemize}}
\newcommand{\resumeItemListEnd}{\end{itemize}\vspace{-5pt}}
%}

\begin{document}

% HEADING
\begin{center}
    \textbf{\Huge \scshape Simon Chase} \\ \vspace{1pt}
    \small
	\href{mailto:schase@uwaterloo.ca}{\uline{schase@uwaterloo.ca}} $|$
    \href{https://linkedin.com/in/simon-chase}{\uline{linkedin.com/in/simon-chase}} $|$
    \href{https://github.com/smchase}{\uline{github.com/smchase}}
\end{center}

% SKILLS
\section{Skills}
\begin{itemize}[leftmargin=0.15in, label={}]
\small{\item{
	\textbf{Languages}{: Java, C, C++, JavaScript (p5.js), HTML/CSS, Racket} \\
	\textbf{Tools}{: Git/GitHub, Bash, Linux, Visual Studio Code, IntelliJ IDEA, \LaTeX}
}}
\end{itemize}

% PROJECTS
\section{Projects}
\resumeSubHeadingListStart
	\resumeProjectHeading
	{\textbf{\href{https://github.com/Bro-Co/Physics-Engine}{\uline{Physics Engine}}} $|$ \textit{Java, Java AWT}}{} \resumeItemListStart
			\resumeItem{Created a basic physics engine from scratch using Java AWT}
			\resumeItem{Explored and implemented optimizations, \textbf{doubling benchmark performance}}
			\resumeItem{Implemented a hybrid of time-based and event-based calculations to handle \textbf{100s of moving objects}}
		\resumeItemListEnd
	\resumeProjectHeading
		{\textbf{\href{https://github.com/smchase/ICS201/tree/master/SUDOKU}{\uline{Sudoku Solver}}} $|$ \textit{C++}}{}
		\resumeItemListStart
			\resumeItem{Researched optimal strategies to solve sudoku problems}
			\resumeItem{Implemented the dancing links algorithm using \textbf{doubly linked lists} to maximize the program's solving speed}
			\resumeItem{Achieved \textbf{solve times of under 1s} for all sudoku problems}
		\resumeItemListEnd
	\resumeProjectHeading
		{\textbf{\href{https://github.com/smchase/Carrier-Pigeon}{\uline{Carrier Pigeon}}} $|$ \textit{Java, Socket}}{}
		\resumeItemListStart
			\resumeItem{Utilized socket to create a local messaging application in Java from scratch}
			\resumeItem{Designed server class to be self-hostable to \textbf{improve privacy and security} for users}
		\resumeItemListEnd
\resumeSubHeadingListEnd

% EXPERIENCE
\section{Experience}
\resumeSubHeadingListStart
	\resumeSubheading
		{Assistant Manager}{Oct. 2019 -- Aug. 2021}
		{Gravity Climbing Gym}{Hamilton, ON}
		\resumeItemListStart
			\resumeItem{\textbf{Managed up to 5 staff}, with broad responsibilities throughout the gym}
			\resumeItem{Took ownership of new initiatives, such as a Bluetooth music system and upgrading equipment}
			\resumeItem{Worked as \textbf{part of a team} to ensure smooth gym operations and drive sales}
		\resumeItemListEnd

	\resumeSubheading
		{Belay Instructor}{Aug. 2019 -- Aug. 2021}
		{Gravity Climbing Gym}{Hamilton, ON}
		\resumeItemListStart
			\resumeItem{Led in-depth courses on how to belay for \textbf{up to 10 customers}}
			\resumeItem{Emphasized best safety practices, leading to a \textbf{100\% pass rate} of the follow-up test}
			\resumeItem{Developed \textbf{communication skills} through teaching}
		\resumeItemListEnd

	\resumeSubheading
		{Youth Coach}{Feb. 2018 -- Dec. 2020}
		{Gravity Climbing Gym}{Hamilton, ON}
		\resumeItemListStart
			\resumeItem{Oversaw a semi-competitive youth climbing program as head coach}
			\resumeItem{Formulated and led lessons and drills, leading to \textbf{3 athletes advancing} to the competitive team}
		\resumeItemListEnd
\resumeSubHeadingListEnd

% COMPETITIONS
\section{Competitions}
\resumeSubHeadingListStart
	\resumeProjectHeading
		{\textbf{Canadian Computing Competiton (Senior Division)}}{}
		\resumeItemListStart
			\resumeItem{Ranked in the \textbf{top 12\%} of 2900+ competitors in 2021}
			\resumeItem{Ranked in the \textbf{top 8\%} of 2800+ competitors in 2020}
		\resumeItemListEnd
	\resumeProjectHeading
		{\textbf{Other}}{}
		\resumeItemListStart
			\resumeItem{Ranked \textbf{1st out of 500+ competitors} in the UWaterloo Financial Literacy Competiton}
			\resumeItem{Reached finals at Ontario lead climbing provincials}
		\resumeItemListEnd
\resumeSubHeadingListEnd

% EDUCATION
\section{Education}
\resumeSubHeadingListStart
	\resumeSubheading
		{University of Waterloo}{Waterloo, ON}
		{Bachelor of Computer Science, 90\% Average}{Sept. 2021 -- April 2026}
	\resumeItemListStart
		\resumeItem{President's Scholarship of Distinction}
		\resumeItem{Advanced stream computer science classes}
	\resumeItemListEnd
\resumeSubHeadingListEnd

\end{document}

% write readmes and docs for projects
% did x with y to achieve z
% quantify stuff, be specific for projects
% could add color
% could add hours worked
% be specific and make it sound good

% could expand on contests and projects
% could combine work positions
% highlight specific skills
% add buzzwords

% hit up Zetyz later

ext: tex

max_stars_repo_name: smchase/Resume

max_issues_repo_name: smchase/Resume

max_forks_repo_name: smchase/Resume


text:
\appendix
\chapter{The \texttt{math} Module}\label{chapter:math}
Picat provides a \texttt{math} module, which has common mathematical constants and functions.  The \texttt{math} module is imported by default.

%In order to use the examples in this chapter, first type \texttt{import math}\index{\texttt{import}} on the command line.

\section{Constants}
The \texttt{math} module provides two constants.
\begin{itemize}
\item \texttt{e = 2.71828182845904523536}\index{\texttt{e}}
\item \texttt{pi = 3.14159265358979323846}\index{\texttt{pi}}
%\item \texttt{inf}\index{\texttt{inf}}: This represents positive infinity.
%\item \texttt{ninf}\index{\texttt{ninf}}: This represents negative infinity.
\end{itemize}

\section{Functions}
The \texttt{math} module contains mathematical functions that serve a number of different purposes.  Note that the arguments must all be numbers.  If the arguments are not numbers, then Picat will throw an error.

\subsection{Sign and Absolute Value}
The following functions deal with the positivity and negativity of numbers.
\begin{itemize}
\item \texttt{sign($X$) = $Val$}\index{\texttt{sign/1}}: This function determines whether $X$ is positive or negative.  If $X$ is positive, then this function returns $1$.  If $X$ is negative, then this function returns $-1$.  If $X$ is $0$, then this function returns $0$.
\item \texttt{abs($X$) = $Val$}\index{\texttt{abs/1}}: This function returns the absolute value of $X$.  If $X \ge 0$, then this function returns $X$.  Otherwise, this function returns $-X$.
\end{itemize}

\subsection*{Example}
\begin{verbatim}
Picat> Val1 = sign(3), Val2 = sign(-3), Val3 = sign(0)
Val1 = 1
Val2 = -1
Val3 = 0
Picat> Val = abs(-3)
Val = 3
\end{verbatim}

\subsection{Rounding and Truncation}
The \texttt{math} module includes the following functions for converting a real number into the integers that are closest to the number.
\begin{itemize}
\item \texttt{ceiling($X$) = $Val$}\index{\texttt{ceiling/1}}: This function returns the closest integer that is greater than or equal to $X$.
\item \texttt{floor($X$) = $Val$}\index{\texttt{floor/1}}: This function returns the closest integer that is less than or equal to $X$.
\item \texttt{round($X$) = $Val$}\index{\texttt{round/1}}: This function returns the integer that is closest to $X$.
\item \texttt{truncate($X$) = $Val$}\index{\texttt{truncate/1}}: This function removes the fractional part from a real number.
\item \texttt{modf($X$) = ($IntVal$,$FractVal$)}\index{\texttt{modf/1}}: This function splits a real number into its integer part and its fractional part.
\end{itemize}

\subsection*{Example}
\begin{verbatim}
Picat> Val1 = ceiling(-3.2), Val2 = ceiling(3)
Val1 = -3
Val2 = 3
Picat> Val1 = floor(-3.2), Val2 = floor(3)
Val1 = -4
Val2 = 3
Picat> Val1 = round(-3.2), Val2 = round(-3.5), Val3 = round(3.5)
Val1 = -3
Val2 = -4
Val3 = 4
Picat> Val1 = truncate(-3.2), Val2 = truncate(3)
Val1 = -3
Val2 = 3
Picat> IF = modf(3.2)
IF = (3.0 , 0.2)
\end{verbatim}

\subsection{Exponents, Roots, and Logarithms}
The following functions provide exponentiation, root, and logarithmic functions.  Note that, in the logarithmic functions, if $X \le 0$, then an error is thrown.
\begin{itemize}
\item \texttt{pow($X$,$Y$) = $Val$}\index{\texttt{pow/2}}:  This function returns $X^Y$.  It does the same thing as $X ** Y$.
\item \texttt{pow\_mod($X$,$Y$,$Z$) = $Val$}\index{\texttt{pow\_mod/3}}:  This function returns \texttt{$X^Y$ mod $Z$}.  All of the arguments must be integers, and $Y$ must not be negative.
\item \texttt{exp($X$) = $Val$}\index{\texttt{exp/1}}:  This function returns $e^X$.
\item \texttt{sqrt($X$) = $Val$}\index{\texttt{sqrt/1}}: This function returns the square root of $X$.  Note that the \texttt{math} module does not support imaginary numbers.  Therefore, if $X < 0$, this function throws an error.
%\item \texttt{cbrt($X$) = $Val$}\index{\texttt{cbrt/1}}: This function returns the cube root of $X$.
%\item \texttt{nthrt($N$,$X$) = $Val$}\index{\texttt{nthrt/2}}: This function returns the $N$th root of $X$.  Note that, if $N$ is even, and $X < 0$, then this function throws an error.
\item \texttt{log($X$) = $Val$}\index{\texttt{log/1}}: This function returns $log_e(X)$.
\item \texttt{log10($X$) = $Val$}\index{\texttt{log10/1}}: This function returns $log_{10}(X)$.
\item \texttt{log2($X$) = $Val$}\index{\texttt{log2/1}}: This function returns $log_2(X)$.
\item \texttt{log($B$,$X$) = $Val$}\index{\texttt{log/2}}:  This function returns $log_B(X)$.
\end{itemize}

\subsection*{Example}
\begin{verbatim}
Picat> P1 = pow(2, 5), P2 = exp(2)
P1 = 32
P2 = 7.38906
Picat> S = sqrt(1)
S = 1.0
Picat> E = log(7), T = log10(7), T2 = log2(7), B = log(7, 7)
E = 1.94591
T = 0.845098
T2 = 2.80735
B = 1.0
\end{verbatim}

\subsection{Converting Between Degrees and Radians}
The \texttt{math} module has two functions to convert between degrees and radians.
\begin{itemize}
\item \texttt{to\_radians($Degree$) = $Radian$}\index{\texttt{to\_radians/1}}: This function converts from degrees to radians.
\item \texttt{to\_degrees($Radian$) = $Degree$}\index{\texttt{to\_degrees/1}}: This function converts from radians to degrees.
\end{itemize}

\subsection*{Example}
\begin{verbatim}
Picat> R = to_radians(180)
R = 3.14159
Picat> D = to_degrees(pi)
D = 180.0
\end{verbatim}

\subsection{Trigonometric Functions}
The \texttt{math} module provides the following trigonometric functions.
\begin{itemize}
\item \texttt{sin($X$) = $Val$}\index{\texttt{sin/1}}: This function returns the sine of $X$, where $X$ is given in radians.
\item \texttt{cos($X$) = $Val$}\index{\texttt{cos/1}}: This function returns the cosine of $X$, where $X$ is given in radians.
\item \texttt{tan($X$) = $Val$}\index{\texttt{tan/1}}: This function returns the tangent of $X$, where $X$ is given in radians.  \ignore{If the tangent is undefined, such as at \texttt{pi / 2}, then this function throws an error.}
\item \texttt{sec($X$) = $Val$}\index{\texttt{sec/1}}: This function returns the secant of $X$, where $X$ is given in radians.  If \texttt{cos($X$)} is $0$, then this function throws an error.
\item \texttt{csc($X$) = $Val$}\index{\texttt{csc/1}}: This function returns the cosecant of $X$, where $X$ is given in radians.  If \texttt{sin($X$)} is $0$, then this function throws an error.
\item \texttt{cot($X$) = $Val$}\index{\texttt{cot/1}}: This function returns the cotangent of $X$, where $X$ is given in radians.  If \texttt{tan($X$)} is $0$, then this function throws an error.
\item \texttt{asin($X$) = $Val$}\index{\texttt{asin/1}}: This function returns the arc sine of $X$, in radians.  The returned value is in the range [\texttt{-pi / 2}, \texttt{pi / 2}].  $X$ must be in the range [$-1$, $1$]; otherwise, this function throws an error.
\item \texttt{acos($X$) = $Val$}\index{\texttt{acos/1}}: This function returns the arc cosine of $X$, in radians.  The returned value is in the range [$0$, \texttt{pi}].  $X$ must be in the range [$-1$, $1$]; otherwise, this function throws an error.
\item \texttt{atan($X$) = $Val$}\index{\texttt{atan/1}}: This function returns the arc tangent of $X$, in radians.  The returned value is in the range [\texttt{-pi / 2}, \texttt{pi / 2}].
\item \texttt{atan2($X$,$Y$) = $Val$}\index{\texttt{atan2/2}}: This function returns the arc tangent of $Y$ / $X$, in radians.  $X$ and $Y$ are coordinates.  The returned value is in the range [\texttt{-pi}, \texttt{pi}].
\ignore{Note that, if both $X$ and $Y$ are $0$, then this function throws an error.}
\item \texttt{asec($X$) = $Val$}\index{\texttt{asin/1}}: This function returns the arc secant of $X$, in radians.  The returned value is in the range [$0$, \texttt{pi}].  $X$ must be in the range ($-\infty$, $-1$] or [$1$, $\infty$); otherwise, this function throws an error.
\item \texttt{acsc($X$) = $Val$}\index{\texttt{acsc/1}}: This function returns the arc cosecant of $X$, in radians.  The returned value is in the range [\texttt{-pi / 2}, \texttt{pi / 2}].  $X$ must be in the range ($-\infty$, $-1$] or [$1$, $\infty$); otherwise, this function throws an error.
\item \texttt{acot($X$) = $Val$}\index{\texttt{acot/1}}: This function returns the arc cotangent of $X$, in radians.  The returned value is in the range [\texttt{-pi / 2}, \texttt{pi / 2}].
\end{itemize}

\subsection*{Example}
\begin{verbatim}
Picat> S = sin(pi), C = cos(pi), T = tan(pi)
S = 0.0
C = -1.0
T = 0.0
Picat> S = asin(0), C = acos(0), T = atan(0), T2 = atan2(-10, 10)
S = 0.0
C = 1.5708
T = 0.0
T2 = -0.785398
Picat> S = sec(pi / 4), C = csc(pi / 4), T = cot(pi / 4)
S = 1.41421
C = 1.41421
T = 1.0
Picat> S = asec(2), C = acsc(2), T = acot(0)
S = 1.0472
C = 0.5236
T = 1.5708
\end{verbatim}

\subsection{Hyperbolic Functions}
The \texttt{math} module provides the following hyperbolic functions.
\begin{itemize}
\item \texttt{sinh($X$) = $Val$}\index{\texttt{sinh/1}}: This function returns the hyperbolic sine of $X$.
\item \texttt{cosh($X$) = $Val$}\index{\texttt{cosh/1}}: This function returns the hyperbolic cosine of $X$.
\item \texttt{tanh($X$) = $Val$}\index{\texttt{tanh/1}}: This function returns the hyperbolic tangent of $X$.
\item \texttt{sech($X$) = $Val$}\index{\texttt{sech/1}}: This function returns the hyperbolic secant of $X$.
\item \texttt{csch($X$) = $Val$}\index{\texttt{csch/1}}: This function returns the hyperbolic cosecant of $X$.  If $X$ is $0$, then this function throws an error.
\item \texttt{coth($X$) = $Val$}\index{\texttt{coth/1}}: This function returns the hyperbolic cotangent of $X$.  If $X$ is $0$, then this function throws an error.
\item \texttt{asinh($X$) = $Val$}\index{\texttt{asinh/1}}: This function returns the arc hyperbolic sine of $X$.
\item \texttt{acosh($X$) = $Val$}\index{\texttt{acosh/1}}: This function returns the arc hyperbolic cosine of $X$.  If $X < 1$, then this function throws an error.
\item \texttt{atanh($X$) = $Val$}\index{\texttt{atanh/1}}: This function returns the arc hyperbolic tangent of $X$.  $X$ must be in the range ($-1$, $1$); otherwise, this function throws an error.
\item \texttt{asech($X$) = $Val$}\index{\texttt{asech/1}}: This function returns the arc hyperbolic secant of $X$.  $X$ must be in the range ($0$, $1$]; otherwise, this function throws an error.
\item \texttt{acsch($X$) = $Val$}\index{\texttt{acsch/1}}: This function returns the arc hyperbolic cosecant of $X$.  If $X$ is $0$, then this function throws an error.
\item \texttt{acoth($X$) = $Val$}\index{\texttt{acoth/1}}: This function returns the arc hyperbolic cotangent of $X$.  $X$ must be in the range ($-\infty$, $-1$) or ($1$, $\infty$); otherwise, this function throws an error.
\end{itemize}

\subsection*{Example}
\begin{verbatim}
Picat> S = sinh(pi), C = cosh(pi), T = tanh(pi)
S = 11.54874
C = 11.59195
T = 0.99627
Picat> S = sech(pi / 4), C = csch(pi / 4), T = coth(pi / 4)
S = 0.75494
C = 1.15118
T = 1.52487
Picat> S = asinh(0), C = acosh(1),  T = atanh(0)
S = 0.0
C = 0.0
T = 0.0
\end{verbatim}

\subsection{Random Numbers}
The following functions provide access to a random number generator.
\begin{itemize}
\item \texttt{random() = $Val$}\index{\texttt{random/0}}: This function returns a random integer.
\item \texttt{random2() = $Val$}\index{\texttt{random2/0}}: This function returns a random integer, using an environment-dependent seed.
\item \texttt{rand\_max() = $Val$}\index{\texttt{rand\_max/0}}: This function returns the maximum random integer.
\item \texttt{random($Seed$) = $Val$}\index{\texttt{random/1}}: This function returns a random integer.  At the same time, it changes the seed of the random number generator.
\item \texttt{random($Low$,$High$) = $Val$}\index{\texttt{random/2}}: This function returns a random integer in the range $Low$..$High$.
\item \texttt{frand() = $Val$}\index{\texttt{frand/0}}: This function returns a random real number between 0.0 and 1.0, inclusive.
\item \texttt{frand($Low$,$High$) = $Val$}\index{\texttt{frand/2}}: This function returns a random real number between $Low$ and $High$, inclusive.

%\item \texttt{randrange($From$,$To$) = $Val$}\index{\texttt{randrange/2}}: This function returns a random integer in the range [$From$, $To$).
%\item \texttt{randrange($From$,$Step$,$To$) = $Val$}\index{\texttt{randrange/3}}: This function returns a random integer in the range [$From$, $To$).  The integer will be equal to $From + K * Step$, for some integer $K$.
\end{itemize}

\subsection{Other Built-ins}
\begin{itemize}
\item \texttt{even($N$)}\index{\texttt{even/1}}: This predicate is true if $N$ is an even integer.
\item \texttt{gcd($A$,$B$)}\index{\texttt{gcd/2}}: This function returns the greatest common divisor of integer $A$ and integer $B$.
\item \texttt{odd($N$)}\index{\texttt{odd/1}}: This predicate is true if $N$ is an odd integer.
\item \texttt{prime($N$)}\index{\texttt{prime/1}}: This predicate is true if $N$ is a prime number.
\item \texttt{primes($N$) = $List$}\index{\texttt{primes/1}}: This function returns a list of prime numbers that are less than or equal to $N$.
\end{itemize}

\ignore{
\end{document}
}


text:
% arara: pdflatex: {action: nonstopmode}

\documentclass[a4paper, 11pt]{scrreprt}

\usepackage[utf8]{inputenc}
\usepackage[english]{babel}
\usepackage[pdftex]{graphicx}
\usepackage{longtable,tabu}
\usepackage[bookmarks=true]{hyperref}
\usepackage{amsmath}
\usepackage{multirow}
\usepackage{rotating}
\usepackage{pdfpages}
\usepackage{url}
%\usepackage{multicolumn}

\hypersetup{
    bookmarks=false,    % show bookmarks bar?
    pdftitle={Manual},    % title
    pdfauthor={Pascal Grosch},                     % author
    pdfsubject={Manual: Recording of Scenarios for Autonomous Vehicles},                        % subject of the document
    pdfkeywords={testing, autonomous vehicle, bachelor thesis, design, recording}, % list of keywords
    colorlinks=true,       % false: boxed links; true: colored links
    linkcolor=black,       % color of internal links
    citecolor=black,       % color of links to bibliography
    filecolor=black,        % color of file links
    urlcolor=purple,        % color of external links
    linktoc=page            % only page is linked
}%

\title{%
\flushright
\rule{16cm}{5pt}\vskip1cm
\Huge{MANUAL}\\
\vspace{2cm}
for\\
\vspace{2cm}
Recording System for Scenarios for Autonomous Vehicles\\
\vfill
\rule{16cm}{5pt}
}
\date{}

\usepackage{hyperref}

\begin{document}
	\maketitle

	\chapter{Installation}
	\section{Build from Source}
	\subsection{Dependencies}
	\begin{itemize}
		\item 64bit Microsoft Windows installation
		\item Visual Studio 2017
		\item 64bit Graphviz installation(obtainable as a development build from \url{https://ci.appveyor.com/project/ellson/graphviz-pl238}) with binaries added to the PATH
		\item PTV Vissim 9.00-12 installation in "C:/Program Files/PTV Vision/PTV Vissim 9"
	\end{itemize}
	\subsection{Building}
	\begin{enumerate}
		\item Create an environment variable called "GraphvizPath" with the base directory of the Graphviz installation as the value (i.e. "C:/Program Files/Graphviz").
		\item Open the solution in Visual Studio 2017.
		\item Build the solution.
	\end{enumerate}

	\section{Use Binaries}
	\subsection{Dependencies}
	\begin{itemize}
		\item 64bit Microsoft Windows installation
		\item 64bit Graphviz installation(obtainable as a development build from \url{https://ci.appveyor.com/project/ellson/graphviz-pl238}) with binaries added to the PATH
		\item PTV Vissim 9.00-12 installation in "C:/Program Files/PTV Vision/PTV Vissim 9"
	\end{itemize}
	\subsection{Preparing the Environment}
	\begin{enumerate}
		\item Run a command prompt as administrator
		\item Type "dot -c" to activate the dot-layout in Graphviz.
		\item Start Vissim
		\item Use Help$\rightarrow$Register COM Server
	\end{enumerate}
	Those steps only have to be done once.

	\chapter{Usage}

	\section{Use the included executable file}
	The system is delivered with a basic executable file that uses PTV Vissim to simulate the traffic. The executable will open a command prompt and prompt the user for the following program parameters:
	\begin{enumerate}
		\item The name of the Vissim scenario. The scenario needs to be in the subdirectory "scenarios".
		\item The name of the database to be used. If there is no database with the given name in the subdirectory "databases" a new on e will be created.
		\item Length of the simulation in hours .This can be a floating point value.
		\item Name of the PDF file which will contain the  visualized graph of situations. The file will be overwritten if it already exists.
	\end{enumerate}
	After the prompt the software will run the simulation and record the situations. At the end the program will output how long the simulation took.

	\section{Use the Included Libraries to Get Data from a Vissim Simulation}
	The project is built as a set of dynamic libraries.
	A library wrapping the most import functions of the Vissim COM-interface is already delivered.
	To use this library create a scenario in Vissim and use the public interface to the framework to add vehicles.
	To start a simulation on your scenario while analyzing the data use \verb+Simulation::runAndRecord+.

	\section{Display Collected Data}
	To display the collected data in a graph open the database which contains the data via \verb+SQLiteManager(database)+.
	Next retrieve all data that was collected in the database via \verb+SQLiteManager::retrieveSituationGraph+ and call \verb+SituationGraph::saveAsPDF+ to export the graph to PDF.

	If you want to export only a single sequence of the graph with a given root situation use \verb+SQLiteManager::retrieveSubSituationGraph+ instead.

	\section{Use a Different Data Source}
	The dynamic library \emph{Recording\_Framework} allows different sources of data input.
	The interface for the data input is defined in \verb+DataProcessor::processData+.
\end{document}


text:
%************************************************
\chapter{Introduction}\label{ch:introduction}
%************************************************

Authentication is a cornerstone of computer systems, and is the process by which a users identity is verified. While most areas of computing continue to evolve rapidly, the dusty old way that we authenticate with computers has not changed for decades.

Usernames and passwords have their origin from back when multiple users were accessing the same mainframe and the operating systems most important job was to handle its different users and their individual files and programs. With the way we use computers today, and especially because of their now ubiquitous presence in almost everything we do, it is surprising that password-based authentication, that was originally designed for such radically different usage, is still the behemoth used practically everywhere.

\fquotet{The continued domination of passwords over all other methods of end-user authentication is a major embarrassment to security researchers. As web technology moves ahead by leaps and bounds in other areas, passwords stubbornly survive and reproduce with every new web site.}{bonneau2012quest}

Password-based authentication is known to be sub-optimal in both its usability and security. Already in 1979 \citet{morris1979password} showed how they were able to crack 81\% of 3000 user generated passwords, using only a small dictionary. A clear impediment is that good security implies a strict and rigours behavior from the end-user, that only a small minority of users are even cognitively capable of~\cite{weirich2001pretty}.

As authentication is merely an enabling task before using a system, many users consider it a hindering, and either unknowingly or purposefully chooses to compromise security for better convenience and usability (such as using the same short password for all services). It is time for a long overdue paradigm shift.\newline

Pervasive Authentication is a research topic, in particular, exploring how to reduce or ease the user-interaction when authenticating, and aims for seamless, but secure authentication. The proof-\textit{of}-concept by \citet{ojala2008wearable} shows how a watch (wearable) can provide an inexpensive, effective, and usable way of authenticating with systems. The user \textit{transparently} authenticates with the system by simply approaching a client. The session is \textit{continuously} kept alive, and as soon as the user leaves the client, the session is autonomously terminated.
When the watch is put on, it first needs to be unlocked. This is done using the user's fingerprint where after it starts monitoring the wearer's vitals. If the watch is stolen, or in any way removed from the wearer's arm, it locks itself. In this way it provides (seemingly) secure authentication in a perfectly seamless and transparent manner, and shows how usable and effortless authentication can be.

However, much work is still left; first of all the proof-\textit{of}-concept is designed for authenticating with a client machine, while most real-world authentications is in fact with web-services~\cite{hayashi2011diary}. Furthermore no security protocol is utilized, and existing protocols are not suitable. Last but not least, for the concept to mature, there is a need for designing for commodity hardware and services.

\section{Contributions}
This thesis has two main contributions. First of all we conduct a semi-structured review of several existing designs for pervasive authentication schemes. Based on the review, we put forward a requirement analysis and a design for a modern \gls{cta} scheme. Our design is the first that targets existing commodity hardware, and could realistically be implemented as a mature solution.

Secondly we propose an authentication protocol that can facilitate an implementation of the design. The protocol is formally verified and analyzed using a mixed computational and symbolic model approach. To showcase the feasibility of core features of the design, a prototype is implemented using the protocol.

\section{Outline}
This thesis is divided into three parts: 1) Introduction and Background, 2) Continuous and Transparent Authentication, and 3) Discussion and Conclusion.

The introduction and background introduces and motivates the problem of password-based authentication, and hints to a solution using wearable devices for end-user authentication. Next, relevant related work is presented and reviewed.

The second part presents our proposed design and implementation. The design is divided into two parts: The first part introduces a novel authentication scheme. The second part presents a protocol supporting the design. Lastly a prototype implementation is presented. The third part discusses and concludes on the presented work.

\vfill

\noindent All material from this thesis is available at
\begin{center}
\url{https://github.com/cholewa1992/cta}
\end{center}

\vfill

%The computer changed society in many ways. Especially the shift from shared computers to personal computers as well as the Internet led to the advent of today's digital era. Although the numbers of computers, their computational capabilities and the usage of computer have had a rapid exponential growth, the dusty old way we authenticate with computer systems have remained unchanged for decades.

%Usernames and passwords have their origin from back when multiple users was accessing the same mainframe and the operating systems most important job was handling its different users and their files and programs. With the way we use computers today, and especially because of their now ubiquitous presence in almost everything we do, it is surprising that Password-Based authentication, that was originally designed for such radically different usage, is still the behemoth used practically everywhere.

%\begin{comment}
%Research have for many years been pointing fingers at Password-Based Authentication as easy to compromise~\cite{morris1979password}, and being extremely user unfriendly~\cite{bardram2005trouble, bonneau2012quest, weirich2001pretty}.
%\citet{adams1999users} advocates the need for user-centered design when it comes to design of security mechanisms. In a field study, they investigate user behaviour and authentication practices within organisations that use passwords. Their findings show that stricter password policies does not necessarily make users produce stronger and more secure passwords, but can in fact encourage bad practices, such as writing down passwords on post-it notes or composing passwords of easily acquirable personal details, such as family members names.
%Usage pattern such as these, will reduce security instead of improving it, due to how easy it would be for an attacker to acquire or guess the password.

%Another major problem with passwords, is that even if an extraordinary user is cognitively capable of remembering many different, complex and unique passwords, and replacing them regularly, research still shows that users will choose the convenience of short, weak passwords over strong and secure ones, simply to reduce the effort and time required to authenticate.
%\end{comment}
%\citet{weirich2001pretty} explains the concept of authentication from a user's perspective as an ``enabling task'', that is only a means to achieve the ``primary task'', which is accessing the protected resource. Thus the authentication process creates an overhead in getting to the ``primary task''. They argue that the willingness for users to behave in accordance with password practices, is small because many users do not recognize the threat of password compromisation as being high enough to outweigh the benefits of being able to quickly type the password and being easier to remember.

%Pervasive Authentication is a research topic in particular exploring how to reduce or ease the user-interaction when authenticating aiming for seamless, but secure authentication. The proof-of-concept by \citet{ojala2008wearable} shows how a watch (wearable) can provide an inexpensive, effective, and usable way of authenticating with systems. The user \textit{transparently} authenticates with the system by simply approaching a client. The session is \textit{continuously} kept alive, and as soon as the user leaves the client, the session is autonomously terminated.
%When the watch is put on it first needs to be unlocked. This is done using the users fingerprint where after it starts monitoring the wearers vitals. If the watch is stolen, or in any way removed from the wearers arm, it locks itself. In this way it provides (seemingly) secure authentication in a perfectly seamless and transparent manor, and shows how usable and effortless authentication can be.

%However, much work is still left; first of all the system is designed for authenticating with a client, while most real-world authentications is in fact with web-services~\cite{hayashi2011diary}.
%Furthermore, no suitable protocol exists for such authentication scheme.

%\section{Objectives}
%Previous work shows that wearable devices offer a both inexpensive and simple way of enabling \gls{cta}. However, work is still needed in either building or adapting a suitable security protocols as well as making \gls{cta} possible with commodity hardware and services.\\

%Therefore this thesis aims to:
%\begin{enumerate}[label=\textbf{\arabic*$\big)$}]
%    \item Put forward a requirement analysis and design of a \gls{cta} scheme.
%    \item Either select or design a suitable protocol for \gls{cta}.
%    \item Show that the protocol can be used in a commodity hardware implementation of the proposed scheme.
%\end{enumerate}

% \section{Scope and Success Criteria}
%\section{Method}

%**********************************t*******
%*****************************************
%*****************************************
%*****************************************
%*****************************************


text:
% !TEX program = xelatex

\documentclass{resume}
%\usepackage{zh_CN-Adobefonts_external} % Simplified Chinese Support using external fonts (./fonts/zh_CN-Adobe/)
%\usepackage{zh_CN-Adobefonts_internal} % Simplified Chinese Support using system fonts

\begin{document}
\pagenumbering{gobble} % suppress displaying page number

\name{JunHong Chen}

\basicInfo{
  \email{alal1995@hotmail.com} \textperiodcentered\
  % \phone{(+86) 131-221-87xxx} \textperiodcentered\
  % \linkedin[billryan8]{https://www.linkedin.com/in/billryan8}}

\section{\faUsers\ Experience}
\datedsubsection{\textbf{Unifly Storage Platform} Sandstone Co.,LTD, Shenzhen, China}{Aug 2018 -- Jul 2019}
\role{PythonBackEndDev, DevOP}{Manager: Deliu Yang}
Brief introduction: Developing with management platform With Python for commercial re-packaged Ceph Storage System as a service (Saas) for
Deploying, Monitoring  re-developed distribution of Ceph.
\begin{itemize}
  \item Implemented feature
    \item [1)]
      Ceph iSCSI Monitor with iSCSI client counter
    \item [2)]
      NAS(network attach storage) Performance Monitor (including nfs & cifs)
    \item [3)]
      Cephx Management in api & ui
    \item [4)]
      Batch install without add ssh key with concurrency control & node recovery
    \item [5)]
      The resource failure & restart speed with optimize the RCM(Resource Control Manager) process FSM
  \item Refactor Disk Management feature with a better abstraction design
  \item Remote Handling deploy & usage problem in various environment(included public cloud & private cloud) for on-site ops engineer
  \item Tech Stack: RabbitMQ, Mariadb with galera cluster, Python, Django, graphite(TSDB Monitor Compoenet)
        Shell(Install & Batch install script & remove script)
\end{itemize}

\datedsubsection{\textbf{Argus Monitor Project} Useease Co.LTD, Guangzhou, China}{Jul 2017 -- Apr.2018}
\role{BackendDev}{OpenSource Projects, collaborated with Team Arugs}
Brief introduction: A Monitor system build for all rounded usage for infra monitor, application monitor, distributed tracing monitor.
And Using machine learn to adjust the threhold and optimize the wrong alert rate.
\begin{itemize}
  \item Implemented feature
    \item [1)]
      Maintain & develop the Web base backend with node.js
    \item [2)]
      Implement the Majority part of Alert System (including the base rule, also add Compared with week feature)
    \item [3)]
      Add multi alert push hook (including Slack & wechat)
    \item [4)]
      Write the basic ai train framework with sklearn (slice data into training and verifcation, trian model, evaluate model precision)
    \item [5)]
      Dockerize the project with multi-dockerfile and docker-compose
  \item Optimized
    Compare to early state bosun, we can change monitoring rules without restart the process
  \item Award
    Successfully Entry the First AIOps Challenage (Held by tsinghua university) & get the 10th of the competition
  \item Tech Stack: Redis, Mongodb, Python, OPENTSDB, tcollector, node.js, sklearn
\end{itemize}

\section{\faCogs\ Skills}
\begin{itemize}[parsep=0.5ex]
  \item Programming Languages: Python，GO > shell > JavaScript
  \item Platform: Linux
  \item Other: git, docker, jenkins
  \item Development: Web, git, BackendDevelopment, DevOPS
\end{itemize}

\section{\faGraduationCap\ Education}
\datedsubsection{\textbf{Guangdong University of Technology (GDUT)}, guangzhou, China}{2013 -- 2017}
\textit{B.S.} in Internet of Thing

\section{\faHeartO\ Programming Apart from work }
\textit{Finish MIT 6.824 Distributed System Course}

\section{\faInfo\ Miscellaneous}
\begin{itemize}[parsep=0.5ex]
  \item Blog: http://ray1888.github.io
  \item GitHub: https://github.com/ray1888
  \item Languages: English - Fluent(CET-6 score:509), Mandarin - Native speaker, Cantonese - Native speaker
\end{itemize}

%% Reference
%\newpage
%\bibliographystyle{IEEETran}
%\bibliography{mycite}
\end{document}


text:
%!TEX root = ../notes.tex
\section{March 23, 2022}
\subsection{Elliptic Curve Factorization}
\recall Pollard $p-1$ method.

The idea to factor $N$ was we take $a\in (\ZZ/N\ZZ)^\times$ and we compute $\gcd(N, a^{n!} - 1)$ where $(p-1)\mid n!$ but $(q-1)\nmid n!$.

The idea for elliptic curves is to take $P\in E(\ZZ/N\ZZ)$ and we calculate $n!\cdot P$.

Let's first fix our code for composite $N$:
\begin{lstlisting}
def invert(a, n):
    if gcd(a, n) == 1:
        return ext_gcd(a, n)[0]
    else:
        print("OH NO!!!!!", gcd(a, n))

def add(P1, P2, a, p):
    if P1 == O:
        return P2
    if P2 == O:
        return P1
    x1, y1 = P1
    x2, y2 = P2
    if x1 == x2 and (y1 + y2) % p == 0:
        return O
    if P1 == P2:
        lam = (3 * x1**2 + a) * invert(2 * y1, p) % p
    else:
        lam = (y2 - y1) * invert(x2 - x1, p) % p
    x3 = (lam**2 - x1 - x2) % p
    y3 = (lam * (x1 - x3) - y1) % p
    return x3, y3
\end{lstlisting}

\begin{example}
    We use elliptic curve $E : y^2 = x^3 + 3x + 7\mod{187}$. We calculate
    \[5\cdot(38, 112)\]
    which fails, since we weren't able to find the inverse of something mod $187$ which wasn't coprime. However, we figured out a factor of $187$, which is what we wanted. We found $11$ which is a prime factor of $187$.

    We can, however, do this modulo each of the prime factors of $187$, $11$ and $17$. We find that
    \begin{alignat*}{3}
        5\cdot (38, 112) & = \cO      &  & \quad \text{ in }\FF_{11} \\
        5\cdot (38, 112) & = (13, 13) &  & \quad \text{ in }\FF_{17}
    \end{alignat*}
    What happened was that we got $\cO$ mod $11$ and got not $\cO$ mod $17$.
\end{example}

In the elliptic curve method, we win if $\#E(\FF_p)\mid n!$ but $\#E(\FF_q)\nmid n!$ and so
\begin{align*}
    n!\cdot P & = \cO \pmod{p}   \\
              & \neq \cO\pmod{q}
\end{align*}

We have $\#\FF_p^\times = p-1\approx p$ and $\#E(\FF_p)\approx p$, so we have about the same `chance of winning'.

\begin{ques*}
    What is the probability of success per unit time?
\end{ques*}
We calculate $n!\cdot P$ takes about $n\log n\approx n$ time. The probability of success is $u^{-u}$ where $u = \frac{\log p}{\log n}$. So the probability of success per unit time if $\frac{1}{n\cdot u^u}$.

What minimizes $n\cdot u^u$? When $n\approx u^u$.

Our crude estimate is about
\begin{align*}
    \log n     & \approx u\log u \approx u = \frac{\log p}{\log n} \\
    (\log n)^2 & \approx \log p                                    \\
    n          & \approx e^{\sqrt{\log p}}
\end{align*}
and our refined estimation is about
\begin{align*}
    \log n \approx u\log u & \approx u\log\left(\frac{\log p}{\sqrt{\log p}}\right)   \\
                           & \approx \frac{1}{2}\log\log p\cdot \frac{\log p}{\log n} \\
    n                      & \approx e^{\sqrt{\frac{1}{2}\log p \log\log p}}
\end{align*}
so our probability of success per unit time is
\[\approx \frac{1}{n\cdot u^u}\approx \frac{1}{n^2}\approx e^{-\sqrt{2\log p \log\log p}}\]

With Pollard's $p-1$ method, our probability of success will increase then decrease. With the elliptic curve method, we can optimize our probability of success by simply picking a new elliptic curve at the same $n$.

This is the best known method for finding small prime factors. The runtime depends on the size of the prime factor we're trying to find instead of the number itself.


text:
\documentclass[prc,amsart,english]{revtex4}
\usepackage{graphicx}
\usepackage{epsfig}
\usepackage{bm}
\usepackage{color}
\usepackage{float}
\usepackage{dcolumn}
\usepackage{multirow}
\usepackage{hyperref}

\usepackage[T1]{fontenc}       % DC-fonts
\begin{document}
\title{Nuclear Talent Course on Machine Learning and Data Analysis for Nuclear Physics, ECT*, June 22-July 3, 2020}
\maketitle

\section{Introduction to the Talent Courses}

A recently established initiative, Training in Advanced Low Energy
Nuclear Theory, aims at providing an advanced and comprehensive
training to graduate students and young researchers in low-energy
nuclear theory. The initiative is a multinational network between
several European and Northern American institutions and aims at
developing a broad curriculum that will provide the platform for a
cutting-edge theory for understanding nuclei and nuclear
reactions. These objectives will be met by offering series of
lectures, commissioned from experienced teachers in nuclear
theory. The educational material generated under this program will be
collected in the form of WEB-based courses, textbooks, and a variety
of modern educational resources. No such all-encompassing material is
available at present; its development will allow dispersed university
groups to profit from the best expertise available.

The present document aims at giving a summary,
with background information as well, of  the Nuclear Talent course, {\em Machine Learning and Data Analysis for Nuclear Physics}.
The course was held online via the  premises of the European Center for Theoretical Studies
in Nuclear Physics and Related Areas (ECT*), Trento, Italy during the period June 22 to July 3, 2020.

This was the sixth course which has been held at the ECT*, the first one in 2012, then 2014, 2015, 2017, 2019 and finally this one in 2020. Although we had to run this course as a fully online course due to the global COVID-19 pandemic, the support from the ECT* has simply been crucial for the successful arrangement and running of these courses.
All practical arrangements, from accepting applications to the practical set up of the online course, were simply central for the success of the present  course held in the summer of 2020.
In total we had 157 participants from countries in Africa, Asia, Europe. Oceania and the Americas. The daily attendance varied from 110 to close to 150.

\section{Report }

\subsection{Introduction}
Probability theory and statistical methods play a central role in
science. Nowadays we are surrounded by huge amounts of data. For
example, there are about one trillion web pages; more than one hour of
video is uploaded to YouTube every second, amounting to 10 years of
content every day; the genomes of 1000s of people, each of which has a
length of more than a billion base pairs, have been sequenced by
various labs and so on. This deluge of data calls for automated
methods of data analysis, which is exactly what machine learning
provides. The purpose of this Nuclear Talent course was to provide an
introduction to the core concepts and tools of machine learning in a
manner easily understood and intuitive to physicists and nuclear
physicists in particular. We started with some of the basic methods
from supervised learning and statistical data analysis, such as
various regression methods before we moved into deep learning methods
for both supervised and unsupervised learning, with an emphasis on the
analysis of nuclear physics experiments and theoretical nuclear
physics. The students worked on hands-on daily examples as well as
projects that resulted in final credits.  The major scope was to give the
participants a deeper understanding on what Machine learning and Data
Analysis are and how they can be used to analyze data from nuclear
physics experiments and perform theoretical calculations of nuclear
many-body systems.

\subsection{Aims and outcomes}

The two-week online TALENT course on nuclear theory focused on Machine
Learning and Data Analysis algorithms for nuclear physics and how to
use such methods in the interpretation of data on the structure of
nuclear systems.

We proposed approximately twenty hours of lectures over two weeks and
a comparable amount of practical computer and exercise sessions,
including the setting of individual problems and the organization of
various individual projects.

The mornings consisted of lectures and the afternoons were devoted to
exercises meant to shed light on the exposed theory, the computational
projects and individual student projects. These components will be
coordinated to foster student engagement, maximize learning and create
lasting value for the students. For the benefit of the TALENT series
and of the community, material (courses, slides, problems and
solutions, reports on students' projects) have  been made publicly
available using version control software like git and posted
electronically on github (this site).

At the end of the course the students should have obtained a basic understanding of

\begin{itemize}
\item Statistical data analysis, theory and tools to handle large data sets.\item A solid understanding of central machine learning algorithms for supervised and unsupervised learning, involving linear and logistic regression, support vector machines, decision trees and random forests, neural networks and deep learning (convolutional neural networks, recursive neural networks etc)
\item Be able to write codes for linear regression, logistic regression and use modern libraries like Tensorflow, Pytorch, Scikit-Learn in order to analyze data from nuclear physics experiments and perform theoretical calculations
\item A deeper understanding of the statistical properties of the various methods, from the bias-variance tradeoff to resampling techniques.
\end{itemize}

We targeted an audience of graduate students (both Master of Science
and PhD) as well as post-doctoral researchers in nuclear experiment
and theory and due to the online format we had in total 157 participants.

The teaching team consisted of both theorists and experimentalists. We
believe such a mix is important as it gives the participants a better
understanding on how data are obtained, and what are the limitations
and possibilities in understanding and interpreting the experimental
information.

\subsection{Course Schedule}

Lectures were approximately 45 min each with a small break between each lecture.
The schedule is included here, with links to online material as well.

\subsubsection{Week 1}

\begin{itemize}
\item  Monday June 22:  Linear Regression and intro to statistical data analysis	(Morten Hjorth-Jensen MHJ). Learning slides at
\url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Introduction/html/Introduction.html} and \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day1/html/Day1.html} and link to  video from lecture June 22 \url{https://mediaspace.msu.edu/media/t/1_ogq38oqq}
\item Tuesday June 23:	Logistic Regression and classification problems, intro to gradient methods	(MHJ). Learning slides at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day2/html/Day2.html} and link to  video for first lecture at \url{https://mediaspace.msu.edu/media/t/1_po1a5e9v} and second lecture at \url{https://mediaspace.msu.edu/media/t/1_wbz4v2gm}
\item Wednesday June 24:	Decision Trees, Random Forests and Boosting methods (MHJ). Learning slides at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day3/html/Day3.html} and link to  video at \url{https://mediaspace.msu.edu/media/t/1_vrt5rxls}
\item Thursday June 25:	Basics of Neural Networks and writing your own Neural Network code (MHJ). Learning slides at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day4/html/Day4.html} and link to  video at \url{https://mediaspace.msu.edu/media/t/1_ksuz0ero}. The link to the video of the additional exercise session is at  \url{https://mediaspace.msu.edu/media/t/1_shte4iw5}
\item Friday June 26:	Beta-decay experiments, how to analyze various events, with hands-on examples . (Sean Liddick) Videos and teaching material \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day5/html/Day5.html}. Link to  video of online lecture at \url{https://mediaspace.msu.edu/media/1_5n2bssbl}. The link to the video of the additional exercise session is at \url{https://mediaspace.msu.edu/media/1_q74f31cw}
\end{itemize}

\subsubsection{Week 2}

\begin{itemize}
\item  Monday June 29:	Neural Networks and Deep Learning (Raghu Ramanujan, RR). PDF file of the presented slides at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day6/pdf/Day6.pdf}. Jupter-Notebook at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day6/ipynb/Day6.ipynb}. Video of lecture at \url{https://mediaspace.msu.edu/media/t/1_58a9xrbt}. Video of exercise session at \url{https://mediaspace.msu.edu/media/t/1_ulont3rg}
\item Tuesday June 30:	From Neural Networks to Convolutional Neural Networks and how to analyze experiment (classification of events and real data)	(Michelle Kuchera, MK). Jupyter-notebook of lecture at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day7/ipynb/Day7.ipynb}. Video of lecture \url{https://mediaspace.msu.edu/media/t/1_2ysd5plh} and video of exercise at \url{https://mediaspace.msu.edu/media/t/1_watjxppf}
\item Wednesday July 1:	 Discussion of nuclear experiments and how to analyze data, presentation of simulated data from Active-Target Time-Projection Chamber (AT-TPC)	(Daniel Bazin). Slides of lectures (PDF) at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day8/pdf/Day8.pdf}. Videos and teaching material \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day8/html/Day8.html}. Video of actual lecture at \url{https://mediaspace.msu.edu/media/t/1_azaquoc0}. Video of analysis of data with CNNs (MK) at \url{https://mediaspace.msu.edu/media/t/1_rozywc7h}. Jupyter-notebook of hands-on session at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day8/ipynb/Day8.ipynb}
\item Thursday July 2: 	Generative models (MK). Slides of lectures (PDF) at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day9/pdf/Day9.pdf}.
Jupyter-notebook at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day9/ipynb/Day9.ipynb}.
Video of lecture at \url{https://mediaspace.msu.edu/media/t/1_ayfst99b}. Video of exercise session at \url{https://mediaspace.msu.edu/media/t/1_wpdmt7cw}.
\item Friday July 3: 	Reinforcement Learning (RR). Slides of lectures (PDF) at \url{https://nucleartalent.github.io/MachineLearningECT/doc/pub/Day10/pdf/Day10.pdf}. Future directions in machine learning and summary of course. Video of first lecture at \url{https://mediaspace.msu.edu/media/t/1_0eiikln6}. Video of second lecture at \url{https://mediaspace.msu.edu/media/t/1_wzyabacr}.
\end{itemize}

\subsection{Teaching}

The course was taught as an online intensive course of duration of two
weeks, with a total time of 20 h of lectures and 10 h of exercises,
questions and answers. Videos and digital learning material were made
available one week before the course begins. It was possible to work
on a final assignment of 2 weeks of work. The total load
wasapproximately 80 hours, corresponding to 5 ECTS in Europe. The
final assignment were graded with marks A, B, C, D, E and failed for
Master students and passed/not passed for PhD students. A course
certificate was issued for students requiring it from the University
of Trento.

The organization of a typical course day was as follows:

\subsubsection{Time and Activity}
\begin{itemize}
\item  2pm-4pm	(Central European time=CET) Lectures, project relevant information and directed exercises
\item 5pm-6pm	(CET) Questions and answers, Computational projects, exercises and hands-on sessions
\end{itemize}

\subsection{Teachers and organizers}
The teachers and organizers were
\begin{enumerate}
\item Daniel Bazin at Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University, East Lansing, Michigan, USA (DB)
\item Morten Hjorth-Jensen at Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University, East Lansing, Michigan, USA (MHJ)
\item Michelle Kuchera at Physics Department, Davidson College, Davidson, North Carolina, USA (MK)
\item Sean Liddick at Department of Chemistry and National Superconducting Cyclotron Laboratory, Michigan State University, East Lansing, Michigan, USA (SL)
\item Raghuram Ramanujan at Department of Mathematics and Computer Science, Davidson College, Davidson, North Carolina, USA (RR)
\end{enumerate}
Morten Hjorth-Jensen functioned as student advisor and coordinator.

\section{Brief summary}

The teachers were fully self-sponsored, and due to the COVID-19
situation worldwide there were no travel or logding expenses. The course was
fully online.

The support from the ECT*, and its year-long experiences with running doctoral training programs and Talent courses, was central to the success of the course. Of uttermost importance was Barbara Gazzoli's help will all administrative matters.  Without her help and the other staff of the ECT*, and the director's (Prof.~Jochen Wambach)
enthusiastic support,  it is unlikely that this course would have run as smoothly as it did, or at all!

Overall, we as teaching team feel the original learning outcomes and goals were met. It was a marvelous group of students to teach. Videos of the lectures will be published by Springer in due time.

This time we did however not perform a course survey, feedback from students is thus missing.

\end{document}

max_stars_repo_name: NuclearTalent/MachineLearning

max_issues_repo_name: NuclearTalent/MachineLearning

max_forks_repo_name: NuclearTalent/MachineLearning