I selected Svelte because it's been one of the most liked frameworks to work with in the last years, accordingly to the State of JS survey \cite{state-of-js-2022}.
It's also one of the best performant frameworks that is currently available that has extremity good performance \cite{js-frontend-frameworks-performance}.
\caption{Screenshot of web application on the page shows basic information about the model.}
\label{fig:model_page}
\end{figure}
This page contains a set of tabs a the top.
Each tab gives different insight abou the model.
The ``Model'' tab, contains only relevent actions ot the most pressing action that the user take.
In Fig. \ref{fig:model_page}, the user has created a model but has not added training data so the page shows a section where the user can input training data.
The ``Model Data'' tab contains a more detailed view about data that has been updated.
The user is given instruction on how create the zip file so that the system can esaly process the data, the upload set can be seen in \ref{fig:upload_data_section}.
This process was original slow as the system did not have the capabilities to parallelize the process of importing the images, but this was implemented, and the import process was improved.
The improved process now takes a few seconds to process and verify the entirety of the dataset, making the experience for the end user better.
Alternatively, the user can use the API to create new classes and upload images.
This step will appear both in the main tab of the model page and in the dataset tab. Once the user instructs the system to start training, the model page will become the training page, and it will show the progress of the training of the model.
During the entire process of creating new classes in the model and retraining the model, the user can still perform all the classifications tasks they desire.
On the administrator, users should be able to change the status of tasks as well as see a more comprehensive view on how the tasks are being performed.
Administrator users can see the current status of runners, as well as which task the runners are doing.
After connecting to the database, the application performs pre-startup checks to make sure no tasks that were interrupted via a server restart and were not left in an unrecoverable state.
Once the checks are done, the application creates workers, which will be explained in section \ref{impl:runner}, which when completed the API server is finally started up.
Information about the API is shown around the web page so that the user can see information about the API right next to where the user would normally do the action, providing a good user interface.
Model generation happens on the API server, the API server analyses what the image that was provided and generates several model candidates accordingly.
The model generation subsystem decides the structure of the model candidates based on the image size, it prioritizes the smaller models for smaller images and convolution networks with bigger images.
The depth is controlled both by the image size and number of outputs, models candidates that need to be expanded are generated with bigger values to account for possible new values.
It tries to generate the optimal size if only one model is requested.
If more than one is requested then the generator tries to generate models of various types and sizes, so if there is possible smaller model it will also be tested.
The runner, when it needs to perform training it generates a python script tailored to the model candidate that needs to be trained, then runs the that python script, and monitors the result of the python script.
If there is too much difference in accuracy, from the best model to the worst model, then the system might decide not to continue training a certain candidate and focus the training resources on candidates that are performing better.
Expandable models follow mostly the same process as the normal models.
First, bigger model candidates are generated.
Then the models are training using the same technic.
At the end, after the model candidate has been promoted to the full model, the system starts another python process that loads the just generated model and splits into a base model and a head model.
During the expanding process, the generation system creates a new head candidate that matches the newly added classes.
The base model, that was created in the original training process, is used with all available data to train the head candidate to perform the classification tasks.
The training process is similar to the normal training system, but this uses a different training script.
Once the model has finished training and the system meets the accuracy requirements, then makes the new head available for classification.
The user then can finally use the API to obtain the results of the model.
\subsubsection*{Expandable Models}
For expandable models, the inference step is very similar to the normal models.
The runner first loads the base model and runs the image through the model, the resultant features are then stored.
Once the features are obtained, the system then runs those features to the various possible heads, and the results are then matched with the stored classes, and the one with the height probability is then selected.
Runners are the name used to reference to the software that can perform CPU or GPU intensive tasks without halting the main API server.
Architecturally, they were implemented as a controller and worker pattern.
When the application that runs the main application starts, the system creates an orchestrator, this orchestrator is a piece of software that decides what work each runner is doing.
The orchestrator runs on go routine created at startup.
During the startup, the orchestrator by obtaining values from the configuration file.
Those values define the number of local runners.
These runners, which are started up by the orchestrator, act as local runners, runners that are running on the same machine as the main server.
Local runners are useful when running the main server on a machine that also has GPU power available to it, and in testing.
Local runners, run inside a go routine, this allows the runners and the orchestrator to communicate using go channels, which are the easiest way to communicate between two go routines.
The orchestrator is constantly waiting to receive either for a timer-based event or a runner-based event.
Timer-based events happen when the orchestrator internal clock informs it of needing to check if tasks are available to run.
The time at which this clock ticks in configured in the settings of the app.
Upon receiving a timer-based event, the orchestrator then checks if there is a new task available for it to run and if there are any runners available for the task to run on.
If there are tasks available, then the orchestrator instructors the runner to pick up the task and run it.
Runner-based events happen when a runner finishes running a task or crashes while trying to do it.
Upon receiving a runner event, the orchestrator checks if it is a success or a failure message.
If it is a failure message and the runner is a local runner, then the orchestrator just restarts the runner.
Upon restart, it adds the runner to the list of available runners.
If the runner is a remote runner, the orchestrator marks the runner as failed and stops sending messages to the runner until the runner informs the service again that is available.
If the message is of success, then the orchestrator just adds the runner to the list of viable runners, independently if the runner is remote or not.
% TODO talk more about remote runners
% TODO talk about how the runner loads images
\subsection{Conclusion}
This section went into the details of how the designed was implemented.
The design was envisioned to be the best possible version of this service, but scope was restrained to the necessities of the system while it was being developed.
And possible features that would make the implemented application closer to the ideal design could have been implemented if there was higher need during the development timeline.
This will be more discussed in the section about a critical review of the work.
\section{Legal, Societal, Ethical and Professional Considerations}\label{sec:lsec}
This section will address possible legal, societal, ethical and professional issues that might arise from the deployment of the software being designed.
Legal issues might occur due to image uploaded images. For example, those images could be copyrighted, or the images could be confidential. The service is designed to provide ways to allow users to host their images without having to host the images itself, moving the legal requirement to the management of the data to the user of the system.
The General Data Protection Regulation (GDPR) (GDPR, 2018) is a data protection and privacy law in the European Union and the European Economic Area, that has also been implemented into British law.
The main objective of the GDPR is to minimise the data collected by the application for purposes that are not the used in the application, as well as giving users the right to be forgotten.
Once the there is no more work that requires the data being done, the system will remove all relevant identifiable references to that data.
\subsection{Social Issues}
The web application was designed to be easy to use and there tries to consider all accessibility requirements.
% TODO talk about this
% The service itself could raise issues of taking jobs that are currently done by humans.
% This is less problematic as time has shown that the jobs just change, instead of manually classifying the images, the job transforms from the classifying all the images that are needed to maintain and verifying that the data being input to the model is correct.
\subsection{Ethical Issues}
While the service itself does not raise any ethical concerns. The data that the service will process could raise ethical complications.
As a member of the British Computer Society (BCS), it is important to follow the Code of Conduct practices. The code of conduit contains 4 key principles.
\subsubsection*{Public interest}
This project tries to consider the public health, privacy, and security of third parties and therefore follows the principle of public interest.
\subsubsection*{Professional Competence and Integrity}
This project has been an enormous undertaking that pushed the limits of my capabilities.
I am glad that I was able to use this opportunity to learn about distributed systems, image classification, go, and Svelte.
During this project, I also followed the best practices of software development such as using source control software and having an audit to tasks and issues.
\subsubsection*{Duty to Relevant Authority}
For the duration of the project, all the guidelines provided by the University of Surrey were followed.
\subsubsection*{Duty to the Profession}
During the research, design, and implementation, and report state all interactions with the supervisor of the project have been professional, respectful, and honest.
To the best of my ability, I tried to design a system that would contribute to the field.
The datasets were selected to represent different possible sizes of models, and sizes of output labels.
The ImageNet\cite{imagenet} was not selected as one of the datasets that will be tested, as it does not represent the target problem that this project is trying to tackle.
The tests will measure:
\begin{itemize}
\item Time to process and validate the entire dataset upon upload
\item Time to train the dataset
\item Time to classify the image once the dataset has been trained
The MNIST \cite{mnist} dataset was selected due to its size. It's a small dataset that can be trained quickly and can be used to verify other internal systems of the service.
During testing only the 9 out 10 classes are trainged and the 10th is added during the retraining process.
\subsubsection{CIFAR-10}
The MNIST \cite{mnist} dataset was selected due to its size. It's a small dataset that can be trained quickly and can be used to verify other internal systems of the service.
During testing only the 9 out 10 classes are trainged and the 10th is added during the retraining process.
The service can create models that represent what the users want in a reasonable amount of time without much interaction from the user.
The models created have the target accuracy required by the users, and the amount of time it takes for the models to train and expand is reasonable and within the margins that meet the success criteria for the project.
This section will go into details to see if the project was able to achieve the goals set forth in the introduction.
The section will be analysing if the goals of the project were met, then shortcomings and improvements off the implementation will be discussed. After analysing shortcomings and improvements, possible future work that be done to the project will be discussed.
The section will end with a general statement about the state of the project.
\subsubsection*{A system to automatically train and create models}
This goal was achieved.
The designed server can create models based only using the data provided by the user without any human interaction.
The model creation system is not as efficient, this inefficient will be discussed more in a future subsection it could be but can still achieve the desired goal.
\subsubsection*{Platform where users can manage their models}
This goal was achieved.
A web-based platform was developed where users can manage all the data related to machine learning models that were created.
The platform that was implemented allows users to create models, upload images related to the model, and then manage the submitted classification tasks.
The platform allows managing any models easily they create with within, meaning that the developed solution can achieve the first goal of the project.
\subsubsection{A system to automatically expand models without fully retraining the models}
This goal was achieved.
A system was created that allows users to add more images and classes to models that were previously created.
And this is done without having to fully retrain the model.
\subsubsection*{An API that users can interact programmatically}
This goal was achieved.
The API implementation allows users to programmatically access the system.
The efficacy of the API is proved by its use in the front end application.
The front end application uses the API to fully control the service.
This means that everything that can be done in the frontend can be done via the API.
Which means that the API can satisfy every need that a possible user might have; therefore this goal was accomplished.
\subsection{Project Shortcomings and Improvements}
Although the project was able to achieve the desired goals, the project has some shortcomings that can be improved upon in future iterations.
This section will analyse some of those shortcoming and ways to improve the service.
\subsubsection*{Model Generation}
The model generation system is a complex, and due to all the moving parts that make the system work, it requires a large amount of to work to maintain.
It is also very inefficient due to the having to generate custom tailored python scripts, that cause the data to be reloaded every time a new a round-robin round needs to happen.
A way more efficient way is to perform all the training directly in go server.
Running the training directly in go would allow the service to be able to keep track of memory and GPU usage, move data from the GPU and CPU effortlessly between runs, and would remove uncertainty from the training system.
The model generation was originally implemented with TensorFlow, this ended up limiting the generation of the models in go as the bindings for TensorFlow were lacking in the tools used to train the model.
Using Lib Torch libraries would allow more control over data, and allow that control to be done in go, which would improve both control and speed of the process.
Unfortunately, when a version of the service was attempted to be implemented using Lib Torch, the system was too unstable.
Problems were encountered with the go bindings for the Lib Torch library or, the Lib Torch library was causing inconsistent behaviour with between runs.
That compounded with time limitations make it impossible for a Lib Torch implementation to come to fruition.
Having a full go implementation would make the system more maintainable and fast.
\subsubsection*{Image storage}
The image storage is all local, while this does not currently affect how remote runner works.
%TODO improve this
This is less problematic when the runner is on the same network as the main server, but if a possible user would like to provide their runners.
This would require a lot of bandwidth for the images to be transferred over the network every time the model needs to run.
A better solution for image storage would allow user provided runners to store images locally.
During the upload time, the API, instead of storing the images locally, would instruct the users' runner to store the images locally, therefore when the runner would need to perform any training tasks with local data instead of remote data.
This would not also not require modification of the current system.
The system was designed and implemented to be expanded.
The dataset system was designed to be able to handle different kinds of storage methods in the future, such as remote storage and Object Buckets, like Amazon S3.
\subsection{Future Work}
This section will consider possible future work that can be built upon this project.
\subsubsection*{Image Processing Pipelines}
The current system does not allow for images of different sizes to be uploaded to the system, an interesting project would be to create a new subsystem that would allow the user to create image processing pipelines.
This new system would allow users to create a set of instructions that images would go through to be added to the system.
For example, automatically cropping, scaling, or padding the image.
A system like this would add versatility to the system and remove more work from the users of the service as they don't have to worry about handling the image processing on their side.
\subsubsection*{Different Kinds of Models}
The runner system could be used to train and manage different kinds of models, not just image classification models.
If the system was modified to have different kinds of models, it would allow the users to run different kinds of models.
Such as Natural Language Processing Models, or Multi Model Models.
This would increase the versatility of the service, and it would allow users to automate more tasks.
With the increase in automation recently, having a system that allows users to quickly build classification models for their tasks, would be incredibly useful.
This project provides exactly that, a simple-to-use system that allows the user to create models with ease.
