PORTFOLIO
The agenda of this project is to apply the improved U-Net
architecture on the ISICs data set to predict the segmentation
response of the lesion image in the test data set, and the overall
minimum Dice score is 0.8.
The data set is challenged by "Analysis of Skin Lesions for Melanoma
Detection" using a data set of annotated skin lesion images from
ISIC archives. The data set contains raw (input data) and segmented
(response data) images of skin patches, which are used to detect
skin lesions. The response data includes a binary mask image in PNG
format, which indicates the position of the original skin lesion in
each input lesion image.
From the project, I learned:
• Solving pattern recognition
problems, especially via deep CNN
• A deep learning framework,
such as Tensorflow or PyTorch
• Algorithmic design
incorporating software engineering principles, while contributing to
a course run open source project, PatternFlow – a pattern
recognition and image processing library for Tensorflow
•
mathematical frameworks involved in understanding patterns and
principles required for all of the above, such as group theory and
tensor calculus
The agenda of this project is to apply the improved U-Net
architecture on the ISICs data set to predict the segmentation
response of the lesion image in the test data set, and the overall
minimum Dice score is 0.8.
The data set is challenged by "Analysis of Skin Lesions for Melanoma
Detection" using a data set of annotated skin lesion images from
ISIC archives. The data set contains raw (input data) and segmented
(response data) images of skin patches, which are used to detect
skin lesions. The response data includes a binary mask image in PNG
format, which indicates the position of the original skin lesion in
each input lesion image.
From the project, I learned:
• Design, build and clearly
document a significant software solution based on a design brief.
• Apply previous experience and skills in multimedia design
and software development to deliver a complete and polished system
that meets your client's requirements within a pre-determined
deadline.
• Investigate and overcome challenges associated
with implementing new designs and technologies.
• Apply sound
project management skills (using relevant tools where necessary) to
successfully deliver a software development project.
• Apply
investigative, experimental, and prototyping methods in the software
design and development process.
• Communicate effectively with
stakeholders to gather requirements and context on briefs, and to
manage stakeholder expectations over the course of a project.
• Develop the necessary skills to work successfully in a
multi-disciplinary team, including the application and evaluation of
different methods for collaborative team work.
• Explain and
apply appropriate methods of user investigation, involvement and
evaluation, using techniques tailored to your specific software
development project.
• Demonstrate sound critical and
professional judgment with respect to the ethical issues associated
with technology projects or products, and apply ethical thinking to
your own work.
LaserTank is an open source computer puzzle game requiring logical
thinking to solve a variety of levels, originally developed by Jim
Kindley in 1995. In LaserTank, a player controls a tank vehicle
which can move forwards, turn clockwise and counterclockwise, and
shoot a laser which can be used to interact with special map
elements. The game takes place in a 2D map divided into grid cells.
The player must navigate from a starting position to the flag in as
few moves as possible while avoiding "game over" conditions. The
game is over if the player moves into a dangerous cell (i.e. water
cells or any cell in the line of fire area of an anti-tank).
Our goal is: to turn LaserTank into a search problem, I will
have to first define the following agent design components:
•
A problem state representation (state space),
• A successor
function that indicates which states can be reached from a given
state (action space and transition function), and
• A cost
function (utility function); we assume that each step has a uniform
cost of 1.
The solver program will: (i) take a testcase filename and an
output filename as arguments, (ii) find a solution to the testcase,
and (iii) write the solution to an output file with the given output
filename. It will generate a solution in the form of a
comma-separated list of actions, taken from the set of move symbols
defined in the supplied laser tank.py file, which are:
• MOVE
FORWARD = 'f'
• TURN LEFT = 'l'
• TURN RIGHT = 'r'
• SHOOT LASER = 's'
From the project, I learned:
• Uniform Cost Search/ A* Search
• Value Iteration (VI) / Policy Iteration (PI)
•
Q-learning / SARSA
Canadarm2 is a remote-controlled mechanical arm aboard the
International Space Station (ISS). The robotic arm is used to
deploy, capture and repair satellites, position astronauts, maintain
equipment, and move cargo.
The system: The simplified Canadarm
operates in a 2D workspace (rather than 3D). In particular, the 2D
workspace is a plane, represented as [0, 1] x [0, 1] C R^2, and is
populated by rectangular obstacles. In addition, there are grapple
point(s) which the end effectors of the robotic arm can attach to.
One of the end effectors must be grappled to a grapple point at any
time. The exact dimensions and positions of each obstacle and the
number and position of the grapple points in the environment are
known prior to execution.
Given the initial and goal
configurations of the Canadarm robotic arm, as well as a map of the
environment, my program will find a valid path from the initial to
the goal configurations. A valid path means that when the Canadarm
executes the path, it will satisfy the following requirements:
1. The path consists of primitive steps. In each primitive
step, each joint of the robot arm cannot move more than 0.001 units
(i.e. radians or arm length).
2. It will not collide with any
of the obstacles
3. It will not collide with itself
4.
The entire Canadarm robotic arm must lie inside the workspace
5. The angle between adjacent arm segments cannot be tighter
than 15 degrees (i.e. angles 2, 3, 4... must be between -165 deg and
+165 deg).
6. The segment lengths must be within the bounds
specified in the input file (i.e. within min and max lengths)
7. Since a primitive step is very small, it is sucient to
satisfy requirements 2-4 at the beginning and end of each primitive
step.
From the project, I learned:
• Probabilistic Roadmap Path
Planning
My task is to develop:
• A network server capable of sending
messages to a client that comply with the desired protocol.
•
A RUSHBAdapter is supposed to work as an adapter for one process
only through TCP (e.g. RUSHBSvr).
• A RUSHBSwitch works like a
network router, and it can be local or global.
The final goal for this programming project is sending and receiving
data across the global network without losses and errors. Data can
be anything that can attached to the adapter, such as netcat, or
RUSHBSvr, or even stdin (as in this assignment).
From the
project, I learned:
• Describe the architecture of the
Internet and the functions of each component.
• Describe
functionality and design principles of communication protocols in
various layers of the Internet reference model.
• Understand
network security threats and their countermeasures
• Design
and implement computer networking protocols based on RFC standards.
• Analyse computer network traffic using a network protocol
analyser tool.
• Networks - layers, ogres & DNS + HTTP & File
Systems
The team aims to design and develop an engaging mobile application
with minimal cognitive demands, for university students that
promotes efficient time management by mitigating distraction and
aiding task management through incentivisation which, in turn,
enables users to study in a manner that is more productive within
the same time constraints
Time management focuses on an individual’s ability to prioritise
tasks and work effectively within a given time frame (Mindtools,
2017). Thus, it was necessary for the team to take these two
aforementioned factors into consideration when developing an time
management application. With that being said, the functionality of
the application is able to be split into four main categories: task
management, time management, progress and incentives.
developed work through interaction design and human-centered design
process to develop an interactive system - an application (FOCUS) in
a group of size four. Completed the three 'cycles' of the process:
• Report 1: Contextual Inquiry, Conceptual Design, Low
Fidelity Prototype (Paper prototyping) & Initial Evaluation
•
Report 2: Adding in UX, Medium Fidelity Prototype developed by Adobe
XD & adding Rigorous Empirical Evaluation
• Report 3: High
Fidelity Prototype (fully functioned) & adding Expert Evaluations
from other group's member
A complete simulation consists of three C99 programs:
-
roc2310: Simulates an aircraft
- control2310: Simulates an
airport
- mapper2310: Maps airport names to ports
Multiple instances of these programs will be executed to carry
out the simulation. The project used pthreads and communicated via
IPv4 TCP networking. The implementation used blocking
communications.
From the project, I learned:
• Compilling c and intial
features
• Processes
• Virtual memory
• File
descriptor and pipe
• Threads and synchronization
•
Networks - layers, ogres
• DNS + HTTP
• File Systems
The program is a simple version of Asteroids.
The AVR
ATmega324A micro-controller runs the program and receives input from
a number of sources and outputs a display to an LED display board,
with additional information being output to a serial terminal and –
to be implemented as part of this project – a seven-segment display
and other LEDs.
The program involves modeling a public transportation network.
Main class:
Passenger — A standard passenger. Included
subclass ConcessionPassenger — extends Passenger.
PublicTransport — Defines the basic vehicle functionality.
Included subclasses Bus, Train, Ferry.
Stop — Responsible for
routing passengers to their destinations
Route — Defines the
basic route functionality. Included subclasses BusRoute, TrainRoute,
FerryRoute.
A desktop application is written entirely in python using Tkinter.
When a user presses either the "Request Quick Help" button or
"Request Long Help" button, the application display a dialog box
that asks the user for their name. Once they have entered their
name, the application should join the user to the queue, display
their name on the screen, and regularly update the amount of time
they have been waiting on the queue (roughly once every ten
seconds).
Further, the "The Questions Asked" heading really
refers to the questions answered since opening the application, and
is tracked separately for quick & long help.
