[Music]
it's the student
showcase I am ridiculously excited this
is definitely the highlight of my year
any other speakers in the room don't
don't don't take offense okay the way
this works we've got a whole bunch of
awesome speakers they're all students
from all across Australia but also local
um we have nine speakers presenting
seven talks 10 minutes one fire
possible we'll find out we're putting
them last so that everyone else gets a
chance to talk in case we all get
evacuated from the building so without
further Ado fire extinguishers maybe
talk next year um okay this is summer uh
she has been programming since she was
nine her favorite emoji is the Space
Invaders
Emoji um and something cool that you
found out about computers recently is
that you learned that computer viruses
weren't originally harmful uh the
creeper in 1971 just displayed I'm the
creeper Catch Me If You Can cool and
this is your talk summer thank you very
much okay hello everyone so this is my
ghost to got Chief first of all hi my
name is Sumer I'm a student at Bergman
Anin school and I'm going to go to UTS
for cyber security next year um I've
done work experience with Microsoft and
examplify I've also am a part of protest
Stars this season and last season um
which is with Blackbird I went to ncss
summer school in Sydney for this year
and I recently won the wick women in ICT
Kate M student encouragement award for
this
year
wo so as an introduction the porogi is
basically this device which was created
by evil socket in 2019 he's a developer
and and security researcher and was
inspired by the popular 1990s toy the
tomag GOI obviously first before you say
anything porn is not a bad word it's
what happens when you try to spell own
but can't and it's a video game thing
from ages ago
[Laughter]
apparently so it's basically a portable
device it's AI powered um and uses used
for Wi-Fi penetration testing it's
operated by capturing WPA and WPA2
handshakes from nearby networks helping
ethical hackers identify potential
security flaws the device stands out
because of its userfriendly design
portability and its interactive
personality it not only educates users
about cyber security but also makes
learning processes engaging through its
tomagotchi inspired interface it's a
compelling tool because of what it can
do and its interactive nature especially
for students and cyber security
enthusiasts
standpoint from an educational
standpoint point the point ofi is highly
appropriate it simplifies complex
security tasks making them accessible to
beginners however its Effectiveness
depends on user responsibility basically
don't be
illegal so the way it works is it uses
AI integration um that learns optimal
strategies from capturing WPA hand
checks it's portable it runs on
lightweight Hardware such as the raspber
pi Z Wave share V4 like I used or the V3
and a battery
it's also interactive through its
displays and shows emotion based
performance here is the interface for my
porag GOI um it's very cute as you can
see uh the porag GOI itself is down the
bottom and the other ones are the web
UI but before we get more into it I just
want to talk about the
importance so cyber secur knowledge is
critical in today's world for
individuals it protects personal data
for organizations it prevents costly
breaches and for society it helps create
a safer digital environment tools like
the pornog GOI make cybercity Concepts
accessible and relatable they Empower
users to take control of their online
security while highlighting the
vulnerabilities we Face
daily this is why learning about cyber
security isn't just for professionals
it's something everyone should care
about the porag Gotti's focus on Wi-Fi
security makes it an interesting entry
point for cyber security education its
Effectiveness depends on how well users
understand and apply its lessons to a
broader context
some statistics there were
2365 cyber attacks in 2023 with 343 mil
338,000 an ethical hacking matters it
identifies vulnerabilities and Wi-Fi
networks raises awareness about
protecting personal organizations and
data encourages proactive defenses
against cyber threats however Simplicity
is the porag Go's double-edge sword
while it lowers the barrier for entry
into cyber security it also requires
users to have a strong ethical
foundation without proper guidance
there's obviously a risk for
misuse there's also learning through the
poroi tool
it offers a hands-on experience Bridges
the gap between theoretical knowledge
and practical application and teaches
critical problem solving skills and of
course we want to raise awareness about
Wi-Fi
security so my project ex itself aimed
to build on the pondi's strengths by
adding gamification features such as
achievements and growth systems these
additions would have increased user
engagement and encourage continuous
learning unfortunately though I fac
significant challenges integrating the
features into the pornog GOI special I
code based and it proved much more
complex than I
anticipated while I couldn't fully
Implement these features I gained
valuable insight into debugging and
software
design this experience highlighted the
importance of planning adaptability and
learning from
failure while my project didn't meet all
its objectives it reinforced the porag
Go's Effectiveness as a learning tool
and I hope to eventually get these
features
working so going back to the actual
pornog GOI itself
again it's very cute but here's a
working video so when the porag GOI says
let's be friends it basically means it
has detected another pornog GOI device
nearby initiating a social interaction
this is basically based of the porogi uh
the tomag GOI like personality
system the channels in the context of a
porogi refers to the Wi-Fi
channels sorry that audio is not
supposed to be working anyway um it
refers first the Wi-Fi channel is used
by wireless networks for communication
um the Wi-Fi channels are specific
frequency ranges within 2.1 GHz and 5
gahz Spectrum used by wireless devices
to communicate the
porogi the porogi usually stays between
1 and 14 as those are 2.4 gahz channels
um they also shows the number of access
points of the top and down the bottom
where it says pawned it is the number of
handshakes during the current session
so first of all I just want to say I
struggled to get the code that I had
made into the poroi operating
system uh these are some of the issues
by the way the reason I don't have the
porag GOI up and running in front of me
at the moment um is Du to the cord being
very very short for the battery system
um because my teacher believes in
something called a budget for some
strange reason
boo um also the original porag GOI ran
from wave sh uh V3 screen but I got a V4
thinking it was the same turns out
they're different and they're different
enough that the libraries don't want to
play nice anymore from this I obviously
learned a lot I've done game development
before and I'm used to working in Python
however I'm not used to working in pi or
Powershell so again it made it a bit
hard so here's some errors as you can
see this eror is the log page where the
poroi would be working but not actually
receiving handshakes um to fix this I
basically had to reflash the whole
system a couple hundred times when
making this this next one was an error
from network connection my computer had
told me that the porag GOI was connected
to my home network but after further
inspection the connection was just way
too weak for the porag GOI to run and it
was just making cute faces not actually
doing any handshake
capturing and lastly we had an updating
issue this was because the porter got
system I was using was so it was much
newer than the original one oh sorry um
and the device didn't want to get the
plugins working so it made a few weird
errors um unfortunately I still haven't
been able to fix this just because again
I can't update the
systems but what I've learned from this
is continuous debugging and researching
actually proved a deeper insight into um
the poi's functionality and even failed
projects contribute to understanding and
skill development and I definitely
learned a lot from this project just for
some insight this is some of the plugins
that I had constructed using basic
python um and it was just a class
structure and some defining of codes um
this was for the
achievements but basically to conclude
the porogi is a small but powerful tool
that demonstrates the importance of
cyber security while its focus is is
narrow it is effective and educates
users about Wi-Fi vulnerabilities and
ethical hacking practices the my project
faced challenges but it underscores the
value of persistence and the importance
of learning through failure tools like
the porag GOI remind us of the need for
proactive security measures and
continuous education in a rapidly
evolving field and I would love to keep
working on this and continue to show you
guys how it updates thank you
was
amazing Brian stop clapping you are up
next I guess I'm going have to kick you
off stage that is fantastic um if you
have
questions keep them in your mind or if
you're as bad as that as I am write them
down because at the end there will
hopefully be some time for questions for
all of the students next up is Brian
Brian
is um Brian's favorite emoji is a thumbs
up emoji nice one that I can actually do
um Brian's been programming for one to
two years and something that Brian has
recently found out about computers is
vectorization specifically you can
actually reduce the amount of
calculations you run by just uh by just
performing operations on an entire array
at a time cool Brian take it
away all right hello everybody uh I will
be here talking to you guys about how I
use Python to find Fibonacci numbers so
for those who don't know if you let F
ofn be the n's Fibonacci number you find
F ofn by adding together F of n minus
one and F of n minus 2 so as a baseline
f of0 is z and F1 and F2 are the same in
that they are both one so the problem
arises with this uh how do you find F
ofn with code now for context at this
point in my life I was in year 11 and I
learned everything that I'm about to
tell you about in this my algorithmics
class and at that point I was finding
the content pretty difficult to
understand I was kind of getting cooked
so hopefully I don't replicate that with
you guys as I go into an explanation of
the first solution which involves a
little something called recursion now uh
as a simple definition recursion is a
tactic where you use simpler versions of
our problem to CC to solve a more
complex variants of our problem and in
programming this normally involves a
function calling itself until it reaches
something called a base case the
simplest iteration of a problem that's
normally so simple that it's a
no-brainer to answer so here is the
first solution for calculating F ofn
I've called it RF of n uh as you can see
those first two if statements up there
represent our base cases F0 equals 0 and
FS1 and FS2 are both one and if we call
anything that's not a base case that's
cool we simply return rfn min-1 plus rfn
minus 2 as a mirror of fnal FN minus1
plus FN minus 2 so this solution works
and it looks pretty elegant but it does
have a weakness namely in its complexity
now uh to put it simply again complexity
complexity basically describes how well
a program will scale in memory usage or
run time as input sizes get bigger for
the purposes of this presentation I will
be analyzing the coming programs in Big
O notation or worst case scenario where
it has to do the most amount of work and
how and I'll be analyzing how runtime
scales alongside this so if we look at
the amount of function calls RF ofn
needs to make with linearly increasing
ends you notice that uh we're starting
to observe sort of an exponential is
growth
with uh the amount of function calls
that I have to make which implies that
the amount of time RF will need to
execute will scale exponentially in size
so to actually prove this what I did was
I made RF of n calculate F0 all the way
to F40 print out how much time it took
for each function to complete SLA down
on Google Sheets and made a little trend
line and I produced these two graphs
right here so to the to the right of the
slide you'd see the output of that
previous program over here uh and to the
left the slide you see a little
calculation that I did which should
measure around how many function calls
that RF needs to actually calculate
given Fibonacci number now both of these
look like exponentials which tell us
that RF has a Time complexity of class
O2 to the^ of n which meaning that if
you plot it out in the graph like this
it looks like an exponential and it will
continue to scale as an exponential as n
increases compared to what we can
actually do with this problem this
solution kind of sucks in terms of time
complexity so I'm going to try my best
to guide you to the logic of the second
solution because this took me a really
long time to understand so if you look
at the process for calculating F of 5
you notice that we have nine function
calls here and you notice that we need
to call F3 twice so if we associate
something here with F3 uh and Define it
the first time we actually calculate it
we can actually substitute its usage its
usage the next time we need it which
takes our function calls down from 9 to
7 which should ideally make our program
a bit faster because it's calling less
functions uh this is the idea behind our
second solution which involves something
called dynamic programming know the
memorization part I do not have enough
time to get into that
so you can think of dynamic programming
as a sort of fancy version of recursion
where instead of just discarding the
simpler cases you are storing them and
using them later on so you don't have to
recalculate them and in certain problems
where these smaller values appear a lot
in calculating these bigger values like
in finding F of n this will save you a
lot of time
so again I just want to Simply preface
that we're simply storing stuff that
we've already done to save time so we
don't have to calculate everything over
and over again so if we let upgraded FIB
be of a function that uses this strategy
to return F ofn we get a function that
looks like this so this looks a bit
complicated to those to those who don't
who haven't really caught on to what I
was explaining but I'll hopefully I can
do a good job at explaining it right
here so here's the storing and
remembering part we Define a record with
all of the Fibonacci numbers that we
currently have of course we start off at
our base cases cuz those are obvious and
the first thing we do when we call our
function is check if it's already in our
record if it's already our record well
that's all cool we can just take it from
our record and return it if not well
that's also cool we can simply perform F
of n = f of n minus1 plus F of n minus 2
shove down our record and return it as
required so to actually figure out its
time complexity what I did was calculate
was make a upgraded FIB calculate F0 all
the way to F 100,000 in increments of
2,500 so doing so gives me these two
graphs uh gives me the graph to the left
over here as you can see uh it takes up
upgraded FIB 0.17 seconds to calculate F
100,000 as opposed to RF taking 10
seconds to calculate F of 40 but I
recognize that we that some of you guys
need a bit more of a mathematically
rigorous way of comparing the two so
let's look at the function calls so
let's look at the function calls as well
so I'm about to run a model which should
uh pretty accurately uh visualize how
many functions that upgraded FIB needs
to call to to calculate a given
Fibonacci number and as you can see here
it mostly like a straight line uh with
if you look at the longest chain of
nodes here with the exception of one of
the base cases down here the actual
Fibonacci number that we're trying to
calculate and the case that we've
already calculated and saved uh most of
these have one branch which tells us
that it's going to scale mostly linearly
in terms of function calls namely if
we're not calling a base case upgraded
FIB is going to call 2 N minus 3
functions which if you plot that on a
graph gives you a gives you a gives you
two graphs that show a similar disparity
with if you compare them with runtime as
well uh it takes upgraded FIB less than
slightly less than 200,000 functions to
calculate F of 100,000 where uh ourf of
n needs like what uh 200 million
function calls to calculate the 40th
Fibonacci number
and analyzing this solution because we
took the because we did the simple
shortcut of just not calculating stuff
that we've already done we have taken an
exponentially scaling solution and we
reduced it down to a linearly scaling
solution to the point where this new
solution in calculating the 100,000
Fibonacci number is 60 times faster than
our old solution calculating the 40th
Fibonacci number so uh I might have
rushed this talk a bit hope that's fine
but uh the moral of the story is that uh
we this this kind of improvement
happened because we took a step back
from because I took a step back from
looking at the Fibonacci numbers problem
realized that these smaller Fibonacci
numbers appeared a lot in calculating
bigger Fibonacci numbers and so and so
adapted to that and so sort of responded
to that aspect of the problem so this
really shows me the importance of
actually thinking things out before
programming something and actually
understanding what you're doing as
opposed to just well uh monkey brain
here's a loop let's hope it goes well uh
I might have rush just a bit too hard
but that's really all I have to say
thank you for listening to my Pon
presentation thank you so much monkey
brain here's a loop Ain't That A vibe
monkey brain here's a
loop I think we've all been there and
may well be again next up is Jun Jun has
been programming for seven years
and his favorite emoji is the I should
make you all guess what this is based
on yes melting oh dedication as I put my
back out okay um uh and something that
Jun recently learned about
computers is that he should be taking
dis backups after his Linux disc
corrupted itself the day before in this
form that's a lesson we all could learn
too take it away J thank you hello so
today I'll be presenting my project
which is um scanning a train with motion
tracking in a phone so um for some
background I was reading Wikipedia once
and I came across this Wikipedia page um
and on this page there was this picture
by the Wikipedia user Theo I found it
really interesting because the
background is really line like filled
with line lines and it has a really
sci-fi shading to it which I wanted to
replicate so how would I do that so
apparently according to the description
this was taken using a technique called
strip photography and it's a technique
where you take one direction space and
One Direction time so what how you do
this is you take a continuous line like
this and then you stack it together into
a full
picture and
this was first done using film so how
you do it with film is you use a slit
um uh yeah you use a slit lens instead
of like a normal lens and this allows
you to
capture single like single lines
together and then like combine them and
this is great and all but I don't have a
film camera so how would I do it with
with my phone um there's also digital
cameras that do this but they cost like
of dollars even like used ones
so I looked I looked at my phone and my
camera um cameras are very expensive my
phone's free my phone can use USB the
line scan camera has to use obscure
interfaces oh by the way um these
cameras are called line scan cameras but
and the problem is they have very high
frame rate and my phone only has 240
frames per second so how do I compensate
for for this well the sensor of my phone
is very wide 4,000 pixels wide much
wider than the one pixel wide line scan
camera so what I decided on doing is
instead of using um single Pixel slices
I take multipixel slices in the middle
and I stack them into a final
picture so this animation so um each of
these uh each of these frames they're
frames in like a video and I can take
slices in the middle and stack them
together into a final picture so I tried
this with a crude python script and this
was the
result it looks very similar to the
first one but you can see there's some
problems for example there's the
contraction in the train in the top part
there's the dilation in the top in the
bottom left and then if you zoom in
further you can see it's not pretty the
the PTV logo is sort of um stretched out
and you can you can maybe see the um
lines in the middle that's because of
that's just because of issues but um so
what I how I ended up fixing this was
using motion tracking but I don't know
how to do motion tracking so I got a
library to do it for
me um this so this is open CV which is a
computer vision uh computer vision
Library it's available for Python and
C++ but I don't know C++ so I use Python
so it um I use the orb key Point finder
The Brute Force keypoint match and I use
I use it also for general image
processing so first with key points so
key points are points in the picture
which are really identifiable and really
easy to find like in multiple pictures
so in this case it's like the rivets on
the front of the train or the um the
dots on the like like the name plate of
the train but it also captures the pass
on the station which is not good because
I don't want the station I want the
train so what open CV allows allows you
to do is it allows you to key Point
match between two frames and with this I
can plot out the distance that key Point
moves like between the frame and
if on on the vertical axis if the
vertical change in position and the
horizontal axis is a horizontal change
in position and you can see it's very
noisy there's a lot of like bad data the
red ones are filtered out by putting an
absolute limit on the vertical axis
because the train doesn't move
vertically it only moves horizontally um
the standard deviation filtering is used
to filter out the horizontal outliers
and what that gives me is the two points
in the middle the blue ones but the blue
dots aren't actually single points there
are a lot of points and you can see
there's two clums the one on the left is
the train because it's moving in the X
Direction you can see the bottom part
shows minus 10 which isus 10 pixels move
this Frame and then the station doesn't
move at all but the train like the
computer doesn't have a concept of a
clump like we do so how do we
distinguish between them so I use a
technique called kernel density
estimation it gives you like a density
graph over the x-axis and you can only
do this with 1D graphs but what um this
allows me to see the peak for the train
and the peak for the station and it's
really easy for my computer to figure
out which Peak is which because the
train Peak is really far away from the
origin compared to the station so anyway
I now that this is done and I can find
the slice Woods to use for every frame I
took I went and took out I went and took
some videos of trains
passing so the top right is the one I
took at huntingdale the bottom right is
the one I took at East pacum with my
friend when the station first opened and
the left bottom left is the one that
took at Edis Veil
so
uh yeah so this is this is a picture I
took it's very um yeah
this one of the four pictures I took
it's probably my least favorite but it
still
works if you zoom in a bit there's like
imperfections but you can't zoom in so
you can't see
them this is another one uh this is
probably my second favorite because of
the coloring it has like a really sandy
beach kind of look to it I like the um
the yellow on the blue and it I think it
looks really nice generally um the
second one the next one is funny because
it actually doesn't fit in this slide
um and the cool thing about this
technique is that the slices can like
just tack arbitrarily long so the
pictures can be arbitarily wide and this
picture is actually 156 pixels W
156,000 pixels wide um it actually
lagged out my slideshow uh slideshow
application when I first opened it so I
had to scale it down
um and my last one is my the one I took
at East packin it's probably my favorite
because the shading worked out so well
it was like sort of foggy on the day so
that reflected well as well and if you
want to try this out for yourself it's
all up on GitHub and you can just
download it and try it if if you want um
you might not want to uh and thank you
[Applause]
that was
amazing wow like shiny shiniest of
trains Zach come on up
here
um awesome all right Zach I'm still
thinking about how shiny those trains
were they're so shiny
okay um Zach has been programming for
almost 5
years um a to guess this Emoji I'm going
to
uh
yeah yes thank you we've got an like
Emoji expert in there yeah I know you um
Zach recently found out which might be a
spoil the opposite of a SPO a nice
throwback to something that Renee said
In This Very Room earlier um that llms
might be very smart smart my words not
not his but they cannot count the number
of letters specified in a word for
example how many RS in
Strawberry Hot yeah like show of hands
it's not to not to um
uh here we
go good you might want to make that
window a bit bigger this yeah yep all
right take it away Zach thank you so
much
big uh my name is Zach ett and today
I'll be presenting the pro rocket League
player game Replay YouTube upload a bot
and that's a very long long Twisted name
but I could not think of a better name
so I'll just explain to you quickly what
that
means so first of all I'll just say what
the bot is and also what is rock league
for anyone that does not know uh rocket
league is an online video game that can
be thought of as as car soccer uh it's
normally played in 2v2 or 3v3 formats
and it's very competitive with many
players playing online with the goals of
climbing the rank system uh these
players can watch professional players
play the game online uh and can learn
from them and improve their own game
play so it's quite common to watch
people a lot better than you to try and
improve uh this is where my bot comes in
which hopes to find the replays of
professional rocket league players uh
download those replays and then upload
them onto a YouTube channel for people
to view publicly so they can learn from
them uh and you can see a little
screenshot of like the YouTube channel I
made uh with videos that's got over a th
videos on there um all right so there
are three main parts of the bot first of
all I need to download the replays uh
once the replays are downloaded I need
to physically record them into an MP4
format uh to upload and then the third
part is uploading to
YouTube uh for the first part which is
downloading the replays uh I first of
all had to use an external API or third
party API because rocket League doesn't
have one uh so I use ball chasing. comom
which many people upload their replays
onto automatically using a plugin for
Rocket league so uh there is loads of
different replays on there so it was no
problem downloading replays of lots of
different professional players off of
there um and I had to use that to
download the replays so I first of all
picked a bunch of pro players I wanted
to play and put them into a uh
dictionary so you can see lots of
different Pro players I've selected and
there steam IDs which I need to pass
into the API to download the replays
so oh sorry um once I have the players I
pi a random player using um just picking
a random one and uh put it through the
API which then downloads onto the
computer and I place into a specific
file that rocket League knows to search
for
replays um once the replays downloaded
and is in the folder it's a bit of a
pain to launch because I need to
physically open it in rocket League to
spectate the replay it's not really in
an MP4 format it's more in a special
format that the game just uses to keep
track of input puts and to replay the it
back to you so you need to really watch
the replay in rocket League to then
record it so I need to actually inside
rocket league with rocket League open on
the computer uh it needs to navigate
through the GUI so I use Pi Auto [ __ ]
which is um a emulation sort of uh
Library which lets you simulate key
presses and uh Mouse inputs so you can
see it navigates through the pause menu
which I've got a picture of up on screen
as well as the replay menu and it just
needs to open the replay that it's just
downloaded using the ballchasing
API uh once the replay is open though
there's another big problem it's
spectating a random player so we
obviously want to watch one specific
player that I've picked beforehand so in
this case we're looking at squishy which
is one of the most popular rocket league
players ever uh we need to make sure
we're actually spectating the correct
player though because in this game here
we can see it's a 2v2 game of Rocket
League you can see four players on the
field we don't know necessarily that
we're going to be spectating the correct
player straight away so we need to
somehow figure out how we know what
player we're currently watching and we
need to switch to a different player if
we're not spectating the correct player
so uh you can see currently I've put a
red box around the name of the current
player was spectating so using the py
Tesseract Library you can take a photo
of somewhere on the screen and then pass
it through uh pesera and it basically
extracts text from it into a string form
format which lets you compare the name
with the pro player you want to spectate
so I just cycle through all of the
players
um I don't know if the video is going to
work it never likes working uh when I'm
in the presentat presentator view
there's another later video which we can
watch but it was just going to be a
video that goes through it so we won't
worry about it for the moment uh it
Cycles through all the players finds the
player we want to watch in this case
it's squishy then it's starts the replay
once it's good to go
uh oh y there you go replay working
never mind uh so you can just see it
quickly Cycles through the players and
then picks the player that it thinks
matches closest with the pro player and
then the actual replay begins and you
can see rocket League starting to play
once it's now spectating
squishy uh uh on to the second part
which is recording the replays so as you
can see there we got up to the part
where the actual rocket League game
started so we need to somehow actually
record the replays into an MP4 format uh
to upload onto YouTube so first of all I
I tried out a lot of different routes
for screen recording so I first of all
used open CV because there
screenshotting functionality as well as
an easy ways to pass the screenshots
into video uh but the issue I had was
none of my replays could go above 10 to
20 frames a second and when you upload
videos onto YouTube normally people
upload at 30 to 60 frames a second so no
one would have any interest in really
watching 10 to 20 frame a second videos
otherwise it just looks too choppy uh
especially when you're watching
fast-paced video games so that wasn't
really going to work for me uh I tried
different combinations of libraries I
tried using pi Auto goey again uh to do
screenshots along with open CV a bunch
of different combinations and just
couldn't get it above really 20 FPS
which wasn't good enough uh also a
library that was specifically made for
screen recording called p screen wreck
uh that still was running very slow and
I couldn't get it working so I was a bit
stuck on this and I had idea how to
screen record in Python uh and I just
couldn't really work it out so I had to
try and create something myself um so I
ended up making my own Library uh called
piast screen cap uh which you can
install using pip uh on screen and
there's also all the code available on
GitHub uh it takes advantage of a
certain screenshotting Library called DX
cam which only works on windows so my
library also sadly only works on Windows
um but my library I managed to use and I
managed to get it to record replay is up
to 90 FPS on the computer which is well
above YouTube's maximum of 60 so I I was
able to use that in my application to
then record replays for
me um on to part three uploading the
replays to YouTube so once my uh library
then up records the whole replays I need
to uh physically upload onto re onto
YouTube so it's in the MP4 format ready
to go um so first of all I had a few
options well I thought I had one option
to start with which was using the
YouTube API which I managed to get
working all the way uh to the point that
uploaded the YouTube videos ready to go
uploaded descriptions uploaded
thumbnails everything was working
perfectly until I realized one problem
which was that you cannot upload public
YouTube videos using the API without
getting permission or without filling
out a form for YouTube so that means the
videos although up on the YouTube
platform could only unlisted or private
meaning that no one could publicly see
them and you couldn't even go in and
manually change it uh and I needed to
fill out a form for YouTube to basically
get that changed uh so this meant either
I could spend 30 minutes filling out an
API form um get it approved maybe takes
a couple days but I once again had all
of the code fully working uh wouldn't
have needed to change anything just
needed to fill out the form get it
approved by YouTube or I could spend
many hours uh dele reading all of the
code that I'd just written uh spending
ages thinking of new ideas of how I was
going to do it and eventually coming to
the conclusion I should just automate it
in a similar way to how I automated the
uh rocket League GUI earlier uh by
simply just moving the mouse around the
screen and just emulating keyboard
presses and mouse presses I think you
can figure out which one I went for uh
here's the choice I made so this is just
uh oh yeah here we go
uh we can just watch what the choice I
made
was not working oh there we go uh so
here's the YouTube Studio page uh you
can see the mouse in the top right uh
it's just selecting file open File
Explorer select the
replay going through waits for the video
to pause this section could have taken a
while so it pauses here for a second so
just give it a couple seconds then it
starts pasting in the title doing all
keyboard presses pasting the information
based on the replay does the same for
the
description uh then Scrolls down need to
say the video is not made for kids so
just check that box really quickly and
show more scroll
down adds in some tags which just helps
with the YouTube
discoverability uh p in a bunch of
different things
there uh click enter a few times and
here we go public video which I couldn't
get before with the API also copies the
video link Just for future thumbnail
uploading which I still actually did use
the YouTube API for uh that's how it
uploads the videos
[Applause]
um uh Frozen that's not
good oh
oh oh there we go um all right uh
there's an other mention though sort of
wanted to make I don't think there's
enough time to talk about it in this
slide but I also need to generate the
thumbnail so he can see an example
thumbnail of one of the YouTube videos
where it uh picks a random car and it
picks a random field and enters in some
of the information based on the replay
so that's an example replay of the pro
player Zen um that's also done in python
as well randomly generating the
thumbnails but uh I think that's a bit
too much to talk about today um lastly
was the project a success
um I left the bot running 24/7 between
mid August to Mid setember last year so
it was running for about 4 weeks uh
straight in towards the end of last year
and it managed to upload over a th000
videos onto the YouTube channel uh
without me interrupting it uh so it was
successful in the fact that it did its
job although it wasn't necessarily the
most popular uh across that month it
gained about 814 views total uh which
like still quite a lot for me doing
absolutely nothing and just leaving it
running but uh that meant like it was
averaging less than a viewer videos so
there were quite a few videos that
reached probably in the T like probably
30 40 views but probably 80% of those
videos didn't even get a single view so
it was quite successful uh in doing its
job but not quite successful in many
people weren't really watching it um
thank you for
listening amazing four subscribers
though four subscribers I think you
reached five at one point until
subscribed
you got to wonder what's happening in
that that video to make someone
unsubscribe yeah I thank you so much
next up we have Annabelle Annabelle is
has been programming for three years oh
gosh hang
on uh this is going to be tricky all
right this Emoji depending yeah
it yeah I if if I were green and a lot
more
flexible
um yeah
Dragon I was really worried about that
one okay uh Annabelle's favorite emoji
is the dragon
Emoji um and the thing that she recently
learned and wanted to share with us
about computers which I tested out today
and can confirm works is that if you
Google best font ever
the font of Google changes to does
anyone want to guess which font comic
Sands beautiful uh I happen to test this
while also typoing and it still
worked so yes good uh good work there um
are we good
fantastic um okay can we give Annabelle
a big round of applause take it away
hi I'm Annabelle I'm a 16 years old and
I'm a recent graduate of glenunga
International High School from adalade
um I've been programming for three years
and today I'll be talking about my
project
Pythagoras so what is Pythagoras it's
kind of hard to explain so I'll let this
demonstrate here's a screenshot of a
video game Celeste the program analyzes
the image to determine which colors are
most similar to the provided SVG that
pride flag then replaces the colors
producing the pride flag you see on the
right hand inside essentially you get a
nice SVG using the same plette of your
image more technically it is a
multiplatform command line interface
program as well as an installable python
package all of which can be run entirely
in your terminal the original reason I
created it as seen here was to generate
Pride flags from the predominant colors
in a photo which leads me to my next
Point um you may now be thinking what
the hell am I going to use this for and
that's totally fair I don't know
anyways here's a short overview of the
process used to develop Pythagoras I'll
talk about a few of them here today um
using regular expressions numpy and
pillow to process images and extract
colors um determining similar colors
I'll talk about that a bit later
substituting colors into the final SVG
and then generating it and producing it
for the user to use so the first step is
to obtain a list of the colors from The
Source image that we can work with as a
command line program I used ARG paaths
to interpret the user's input to get the
path to the image then pillows very
convenient get colors function to obtain
a list of
colors next we do the same thing but
with SVG svgs are a type of vector image
format that can be scaled infinitely
while still um preserving quality so
they're fairly popular for representing
icons and in my case flags colors are
present in svgs as hex codes so the
question is how do we find all those hex
codes the answer is unfortunately
Rex so hex hex codes as we usually know
them generally take the same form they
start with a hashtag and they have six
characters after them so it should be
pretty easy to find and extract a hex
code using a regular expression such as
this so here's a reminder of the Rex I
developed from the previous slide it
looks great so let's test this out so
here we have a have some code for an SVG
that's filled with a a shade of magenta
so that one matches great okay so it
doesn't seem to work with three digit
hex codes that's because we only check
for six and
finally I failed to account for the fact
that SVG support arbitrary color names
as fill colors including Papa whip which
is quite frankly a nonsense name for a
color so now you need to remember that
at the time I was making this it was
originally intended to only be used for
Pride Flags so I seeded the program with
an assortment of pride flag SVG files
that users could use by default this of
course meant that I had to check if all
the colors in in my template svgs would
actually work with my program and they
weren't affected by any of the three
issues the issues I saw on the previous
slide so I thought to myself I'm a
programmer I can make a quick program to
like sort that all out instead of being
boring and reading through all my SVG
files to exchange them manually so I
went through each file and exchange it
man exchange it man manually and you can
see there bunch of files I changed um
took me over an hour don't do it so
later on I went ahead and wrote a
function this converts all three-digit
hex codes into six-digit hex codes
converts um nonsense color names into
actual hex codes by reading from a Json
file so it standard basically
standardizes the svgs to be used
normally okay next the reason why I
wanted to extract the hex codes of each
color is because it's easier to find
similar colors this way colors can also
be expressed in an RGB format we can
show this as a topple consisting of
three elements the red component the
green component and the blue component
if we think of these colors as points in
3D Vector space then the similarity of
two colors can be found by determining
the shortest distance between them or
like the modulus of the vector between
them here I use Python's math module to
find the linear distance between any two
colors then ultimately identify which
pairing produced the minimum
difference theoretically this works the
problem is that colors that the program
deems are similar aren't really what we
would consider the same for instance
it's generally agreed upon that the
human eye can distinguish more shades of
green than anything else and the way
that each individual person um sees
color is always going to be different
even just by a small amount here's an
example I'm sure many of you
[Music]
recognize so one night when searching
for a solution to this issue I stumbled
upon this website which provided handy
conversion for colors into different
color spaces in particular there's
something called the cab color space
which aims to accurately replicate how
humans observe color by recognizing that
it's really actually quite nonlinear I
added a python implementation to convert
an RGB tle into a cab topple as an
alternative algorithm to just straight
Pythagoras's Theorem this generally
produces more accurate um results in
terms of color perception but it isn't
always the
case Okay a lot of things about this
project are subjective for instance how
do you know that the colors the program
spits out are actually like from my
image there are two parts of this first
you log the coordinates of where the
colors are found numpy lets you do this
provided you pass it an image you are
then able to retrieve a two-dimensional
array where each cell is equivalent to a
pixel correspondingly each cell
represents a color from the original
image all that's left to do is filter
for the colors that we want then get the
coordinates from there secondly you have
to actually actually find a way to
represent the coordinates on the image
which is something that we can do with
pillow I wrote a function to dynamically
size and draw a surrounding Circle based
on the size of the original image so if
you enable the Highlight flag a new
image will be produced with red circles
uh you can probably see a couple over
there um showing where each of the
similar colors can be found so yeah just
check over there and each of those red
circles corresponds to one color on the
final
SVG okay I'll be showing a few other
examples here with brand logos that
you're probably familiar with um here's
a quick example using a screenshot my
terminal and the slack logo using the
cab algorithm so using it you can see it
produces a more muted
color and here's another one that uses a
picture of alen snakes live bag and the
Google logo with a low cost approxim
approximation this is a different
algorithm um the not noticeable change
here is that the program has found a
lighter blue on the source image to be
most similar to the original
color um I've got a video demo here but
I can do a demo uh like a actual live
demo if that
works
okay open my terminal over here feel you
can see that
okay that what I feel so um you can see
there are a couple of things in that um
pan line aduino PNG represents my source
image um- F Pyon SVG so I've decided to
uh see if I can rep replicate the Pyon
um logo using my image source image
Arduino PNG and there are two flags
verose and highlight highlight will
produce the red circles and verose will
just log a bunch of
stuff okay hopefully that
works yeah so there we
go and
now I will open the actual image
okay
so don't know if that's opened open
yourt oh it's opened here
yeah that is the pon logo that it's
disappeared again that's the pon logo um
generated
from this random picture of an Arduino I
had lying
around and if you look at the logo logo
up here that's the original one and this
is my new one and this one you can Al
also see is kind of less saturated than
the
original okay um now go back to our
presentation
yeah okay so a couple other things about
this program um I've documented a lot of
it online and also provided tools for
debugging and development in an open
source repository um there are a few
floors however and that's uh it's quite
slow when you run it with large um large
images high resolution images and
secondly it favors exact color matches
over the dominant pette of the image so
it's easier for the program to find
exact color matches but they don't fully
like represent the image um lastly it
doesn't support some more complex svgs I
haven't looked a bit too much into that
because I only found about it last night
and so yeah does it work technically it
does and you can try it out by typing uh
pip install Pythagoras wherever you want
um haven't been haven't tested it on Mac
though uh so over the course of this
presentation did I think of any more
uses for it uh no uh it's essentially a
novelty tool but did I have fun making
it
absolutely
yeah thank you for
[Applause]
listening thank you so much I I um I
needed to pause and take a photo of that
uh yeah come on come on Deck come on
deck of your last de because I'm going
to be making sure that those links are
posted in the education track on Discord
uh because you may not have thought of
use for this but I guarantee you that in
the audience you have a lot of people uh
trying to find and finding good uses for
this thank you so much next up the
second last talk is Toby Toby has been
programming
for 5 to six years um oh gosh okay his
favorite
emoji eyes eyes yes okay
yeah um and recently he made the mistake
of learning about pointers and now they
haunt your
nightmares we've all been there we've
all been there Tak it away Toby hello um
I am Toby and I really like noise
algorithms I find them really cool the
fact that a computer can take in some
random inputs in a vector and return
value that's like kind of like its
neighbors but kind of different is
really
fascinating um but what is a noise
function a noise is the name for the
output from a noise function and will
typically be a value between 0 and 1 or
0 and
255 it can take several forms it can be
2D 3D 1D or even 4D depending on the
function many noise functions can
actually be fairly easily adapted to
work in any Dimension n uh but yeah
that's the main three that noise
functions normally work in uh here's
some examples of noise functions so a
lot of noise functions will output
complex gradients like the ones I'm
showing now they've got a really large
amount of use cases I've personally seen
them be used for train generation where
the values returned will correspond to
Heights so we've got pein noise which is
some fancy product of vector dot
products uh then fractal pear noise
where you layer multiple ones Veron
noise where you get uh random points and
find the distance to them Simplex noise
which I have no idea and my one which
has been colored fractal iterative Point
averaging um so this sort of thing can
be seen in games like Minecraft which is
a 3D sandbox and Terraria a 2d sandbox
both of these games rely really heavily
on noise functions to help create the
random and in Minecraft's case infinite
or near infinite uh terrain
generation noise can also be used for
animated textures and CGI in fact one of
the first noise functions invented was
pein noise and it was invented for the
movie Tron where it was used to create
land masses cycling textures and
probably way more but uh it's hard to
find specific use cases for it in
it uh I came up with a basic idea behind
the noise algorithm that I'll be talking
about back in like April of
2023 I think and I was still just
getting the hang of python back then so
I made the first version of the
algorithm in scratch and I was going to
talk about that but it was like 12
minutes so I cut that bit out um it's
actually a really simple algorithm
though uh you start by placing any
amount of points on like a pixel canvas
each with a completely random value
assigned between 0 and 255 next you get
a list of all the possible coordinates
shuffle them and then go through uh it
one by one
for each element of that list you place
a point at the specified coordinates
then Loop over all the points to find
the two closest points to it the new
points value is set to the average of
the two closest points and once that's
done you move on to the next once you've
done this for all the points in the list
you're able to step back and view the
finished
texture now the only problem with this
is that the time it takes to generate is
proportional to the amount of points or
the product of the length and the height
multiplied by themselves so in Big O
notation that's o of n s
and we do not like quadratic uh Bigos no
um so it kind of goes without saying I
knew I'd have to optimize it eventually
but to start with I ignored it because I
didn't know how um I was still getting
the hang of python at this point and so
I decided to get it working before I
tried to fix this uh because you can't
like make something better if it's not
there at all um but I had a fix in my
mind but I had zero clue on how to
implement it
uh so this is the first uh sort of
iteration of the code uh start by
importing some libraries and defining
some parameters so we've got starting
complexity which is the number of random
points we start off with with completely
random values uh we've got the
iterations total number of points to be
placed because for this one for some
reason I wasn't doing the shuffling the
random coordinates I was just placing
them at random places and hoping it
worked out uh and then the resolution
which is the size of the place pixels so
you can increase the res res olution to
make it sort of blob and decrease it to
make it uh not hide the bits it missed
as much um so the yeah instead of
randomizing the coordinate list points
are generated with random coordinates
and yeah the main problems with that
approach were that uh one you couldn't
guarantee that points wouldn't be
repeated it wouldn't overlap one point
with another one that had already been
done and two you couldn't guarantee that
every point was hit um not sure why I
did it like that but I did
uh so yeah changing the resolution can
compensate for any missed or overlapped
parts and a final step called Smooth
iterations involves processing every
point to set it to the average of its
neighbors uh average of its nonzero
neighbors um and you average it onto a
buffer frame so that you're not
averaging ones that have already been
averaged because that can create like
weird
smears create Point function uh it will
generate a random X and Y position
within the bounds of the screen called
uh oh GL get closest points and set the
height to the average and add that to
the list add that point to the list get
closest points is such a great function
that I have no clue how it works um I
yed it from like stack Overflow or
something when I was first making this
because I was using Pythagoras Theorem
to just find the closest points but that
was really slow and I wanted to speed it
up it still took like 6 hours to
generate like a 1,00 by 1000 pixel thing
though um so yeah originally used
Pythagoras theem to find the
points uh and then for Loops we create
all the starting points create all the
point
points and in the main Loop we have some
basic uh the main Loop is just one in
the like bottom rsh sort of corner we
have some basic P game Necessities cuz
Pi gamees the library I was using to
visualize all this so I could update the
C Level because I am visualizing the
noise in this one as sort of like red I
mean blue and green
Islands um so yeah we Loop over
everything Set uh each Point's color to
a function of the sea level and its
height and then draw a circle of radius
equal to the resolution I was pretty
happy with that um I had to leave it
running in the morning go to school and
come back and it still wouldn't be
finished but uh it still worked and that
was good enough for
now um eventually though at the start of
2024 I was working on like a really
boring assignment for English and I was
desperate to procrastinate so I opened
up my python IDE and look through my old
projects before finding this one again I
decided I was ready to tackle the
problem of optimization and my idea for
this was to use
trunks at the moment due to the fact
that I was drawing all the points in a
single list to find any information
about the distances to the reference
point I had to Loop over every single
point when as a human I'd be able to say
I don't need to worry about those points
or those points I can just worry about
the ones right near it to fix this uh I
can store each point in a chunk so as
I've shown there each chunk uh led by
the S like Boulder lines represents a
portion of the screen that's X pixels by
X pixels big and these trunks would be
arranged in a grid
pattern I can then access the trunk of
any specific point shown by the Red Dot
and only check its trunk and the
neighboring trunks for close points this
means that the total amount of points
I'm looping over for any one point goes
from n where n is the amount of pixels
on the sample down to 3 * the chunk size
squared where C is the size of each
chunk and because C is a constant that
doesn't change with the input uh pixel
um mounts uh this is now a linear
scaling which is a lot better than
quadratic yay uh but to implement this I
needed to create a 2d Matrix of chunks
where each chunk contained in of itself
a 2d Matrix of points making for a 40
Matrix in total um and then I can just
reference a specific point in The Matrix
with like Matrix trunk X trunk y point x
point Y and that's actually it's like
python is so nice to that sort of thing
it's so easy
uh so it starts off the same uh reset
chunk map just generates a 40 Matrix
with every Point height set to ne1 we uh
generate some complexity points more for
Loops uh check if the random value
between zero and point Chan is one if so
it sets that point to a random height so
so for this version we are starting off
by putting random uh putting random
points with a random chance in each
trunk instead of putting a predetermined
amount of trunks uh points randomly in
every
chunk um and then everything oh I love
all Chords it's like some monstrosity of
list
comprehension um it hurts me to look at
but I think I probably learned about it
a couple weeks before and I was like
this is a great use case um it wasn't
so yeah uh generate points Loops over
everything this is all just kind of
boring generate points is a kind of
interesting function we uh have d X and
Dy and they're uh sort of like offsets
we Loop over them check if they're in
bounds and then we do some funky maths
to find the points and yeah um but now
I'm running out of times so I really
want to quickly showcase some of the
cool
patterns uh this is a 300X 400 one and
this is a fractal uh iterative Point
averaging one and it's created by
getting a large one which uses large
trunk sizes and a low amount of points
per trunk and cre creating a small one
and then overlapping them to create
this I also made this little uh one uh
file which will do it all and it will do
it live but it's showing on the wrong
display so really quickly no okay well I
think my time's out so thank you oh no
go on go on put the
display get Give It 2 seconds do you
have the display Give It 2 seconds go on
go on go on you can't just leave was
hanging like
that yeah I can't wait that long your
Cod and make fix your code
live love it how hard how hard could
that be how hard oh ER is Windows P yeah
I just got a Windows p Ah but the thing
is it's a collaborative and then
duplicate debugging session see
fantastic okay
pair programming with all of everyone
now look we get to watch it Place its
points as it
goes so
pretty and I mean it takes a minute but
I'm like a 100x 100 one in the updated
version takes uh .9 seconds on average
whereas in the old version with n s
complexity it took 70 second uh 77
seconds which wasn't great
uh but yeah we'll keep doing that if
once it's all filled in it will color it
blue and green depending on the sea
level I think this is the most Zen I've
felt in
months we
just yeah it's a crackling fire I'm
getting crackling fire Vibes the new
screen for everybody yes this is
definitely the new screen saver yeah
all right everyone can you take a big
breath
in and a big breath
out I think we felt some Zen yeah
there's also some like errors around the
sides with this version I'm not sure
where they came from but I just want to
point them out Zen focus on the Zen
there are no mistakes only happy
accidents happy accidents indeed can you
all give Toby a massive Round of
Applause
there is one more
[Music]
talk there is one more talk and while
they get set up oh I will intro them and
my the fear in my voice is not not
actually because of the potential fire
risk cool um but actually because now I
have three separate emoji that I need to
make you all
guess no none of them are fire Emoji um
okay so hang on while we do this now we
will be joined by Derek wave good don't
drop the robot um helius hi wave and
Matthew wave um all right d has been
programming for 4 years um his favorite
emoji is
um yeah shark Emoji excellent uh and he
has been learning Cur uh reinforcement
learning for the past year and recently
discovered how it can be applied to
train agents to make decisions in real
life environments it's fascinating to
see how algorithms can learn through
trial and error much like humans
actually
um yes that is great okay uh hel oh gosh
helus has been programming for seven
years heli's favorite emoji oh wait
you've got you've
moved I feel like we're having a weird
mime thing
now sorry they were I I heard things but
I didn't hear what they
were
uh it's a little bit more green and red
watermelon yes
nice nice um and hel is like that most
webcams can capture infrared light o
file that away under useful maybe and
Matthew has been programming for seven
years as well I asked Matthew about this
Emoji Choice specifically asked him what
it was called he said he didn't know he
just chose it randomly do do you want me
to choose a different one um so I don't
I I mean the
th this is the Emoji the Pinchy
fingers I yeah I'm this close Okay I get
okay I'm this close we're this we're
this close to to this close this big um
and Matthew recently M wanted to share
something that he recently learned which
is the only Windows uh uh the only
reason that Windows is the standard is
due to marketing
um yeah um those those were our Emoji
thank you for sharing them those were
our facts thank you for sharing them um
I get to keep stalling
until uh we get there um I would but I
there's something in my like in the
dance
area dance down there but it wouldn't be
captured on the film and it's just it
would be unfair if I didn't get to share
you need the tape no good okay maybe I
will dance down
here um um maybe we all need just need
to breathe again and keep Imagining the
uh the Zen noise we have
a what's my favorite emoji actually my
this this sounds like I'm just pandering
now but my favorite emoji is the parrot
Emoji because I oh I I just spoiled it
I'm so sorry I'm like
[Applause]
yeah all all the way the through the
parro Emoji
um yeah well since we find ourselves
here in Melbourne and I don't often come
down to Melbourne maybe I should just
make a pitch for the girls Programming
Network which has a chapter here in
Melbourne and and there are free
workshops for high school girls to uh
and gender diverse kids to learn
programming and have fun and get pizza
cuz you know yeah yeah come come for the
pizza stay for the friends um but if
you're not in Melbourne maybe you're in
Sydney guess what there's there's a
chapter for you there too maybe you're
actually from Perth hey there's a
chapter there too um canra oh yeah we
got you covered don't worry com next
year two more coming next year so many
so many things Adelaide and
Brisbane um but if you don't live in any
of those places and you want a gpn
network near you and you want to give me
and Renee more
work yeah uh and yourself more work as
well yeah hit us up um does anyone else
want anything spooked since I'm
here oh yes we we also need uh fabulous
volunteers all of the time wonderful um
have we all been enjoying
Pon yes did you know you could volunteer
at Pon as
well
um um okay how are we
going are we good we're good we're good
maybe rotate the thing away from the CR
what
no what do you mean rotate it away from
the crowd give a fight
did you just aim it at yourselves
instead of at the crowd yeah I mean
replaceable
yeah I feel like I feel like I'm in I
feel like I'm at the zoo at the seal
show and I'm need to warn the crowd that
the first two rows are the Splash
Zone but actually is this the Splash
Zone I I feel like we okay hang on let
me let me see a view of hands this area
of the crowd do you want to be the
Splash
Zone not if it's fire How likely is it
going to be fire or confetti I think it
should be all right I I think we're
happy to be the Splash Zone yeah come on
live dangerously let us be the Splash
Zone okay a aim it towards the camera
that's right think of the poor people
watching this later on they want to be
involved okay I'm not here with o um so
can I yeah yeah yeah what's duty of care
I'm not that teacher okay
so can we welcome last talk up take it
away hi um we're presenting Bev it is a
bip bipedal walking confetti ejecting
robot with voice control it's
essentially a confetti launcher mounted
on a pair of legs that follow you around
and you can talk to it and give it
commands with voice controls uh so who
are we I'm Matthew on my next here is
Derek and then Helios on the very edge
um Derek has been doing python C++ and
Lua um he's broken a couple things um so
was so of all of us really but uh
yeah um so this is what we've done right
so Derek was the main legs component
Helios did the main confetti dispenser
and that was the voice controls that
kind of put them together uh first up
I'll give it to Derek to talk about his
legs okay so um yeah I made the bipedal
walking uh robot um using reinforcement
learning uh if you don't know what
reinforcement learning is it's basically
just um a discipline where okay thank
you it's basically just a discipline
where it uses uh trial and error to
figure out like I know why it exists and
basically like it's like it basically
tries to figure out what its goal is and
try to maximize what its goal um wait
okay to better explain this we can use a
like a simple example of a dog in an
entree dog in a yard if we like throw a
stick the dog will first just like
explore around for a bit and but
eventually you'll find the stick and
bring it back to us um when it brings it
back to us uh we'll give it a treat or a
reward and then the next time we throw
the stick around um the dog won't
explore around as much but go straight
to the stick and bring it back to us
that is the basics of reinforcement Lear
and um the next thing I'll talk about is
the the type of reinforcement learning
algorithm that I chose so I chose
td3 uh which stands for twin delayed
deep deterministic policy gradient yeah
it's a mouthful but uh td3 is basically
just an algorithm that helps the
computer program to make um good
decisions um the T3 has two components
uh one is the actor uh it's basically
just like a coach that decides what
moves to make in a game
um like it looks at the game and says
let's try this move and the critic is
basically just a judge that says that
was either a good move or was a bad
move um what's special about td3 it has
two critics um this is because sometimes
one judge might be a little too
optimistic and say a bad move uh is good
is good but by having two judges the
agent only listens to the more cautious
one or safe one and this makes learning
more steady and
reliable another thing it utilizes is
delayed learning so um uh in a game what
was I saying uh yeah okay um in delay it
uses delayed learning where um in a
game it okay I forget forgot what I was
going to say but it basically just lets
the actor or the coach change its
strategy only after a few moves um this
gives it uh time to learn from better
feedback uh better feedback from the
critic uh the next thing it utilizes is
noise so in a game um uh to better
explain this we can use a game example
where um the U the the robot would use
the exact same strategy every time in
the game but this is bad because it will
it reduces exploration and this um stops
it from learning new strategies or
better strategies in the long run um td3
um improves this by adding a little
noise or Randomness to the moves like
trying something slightly different to
discover better
options and that's a really basic
rundown of the algorithm now onto the
build of the robot the robot is built on
a 3D printer frame where it is connected
to 10 servos three arduinos and a
Raspberry Pi uh there's also a camera on
board um which is again used for
computer vision um the entire robot is
powered by an ATX power supply that I
found at the dump but yeah but yeah
um uh the the sensors that I used for
the robot um um well actually let me
give a example um the senses uh are used
in the robot so it can learn from its
environment so it can optimize its goal
uh the sensors that I used were an MP
6050 which gives the robot its
orientation data
um there was acceleration data but I
didn't use it for some reason I don't
know um the next uh the next sensor I
used was a camera um this uh gives the
robot data on how far a human is this is
relevant to his project CU he said oh I
need the confetti close to a person so
yeah so I was like okay sure I'll give a
camera to it um the next uh sensor I
used was a pressure plate sensor these
are on the feet of the robot and it's
basically just two metal plates and when
you connect them it makes a closed
circuit it's pretty simple um this allow
this tells the robot if its Feats feet
are touching the ground which is like
extra input for
learning um the robot has three arduinos
and one razy piie the first Arduino is
connected to the mpu 6050 for
orientation data the second Arduino is
connected to seros and pressure plate
data and the third U know is connected
to my battery backup power supply um all
it really is is just you can connect two
batteries it uses a voltage of Auto to
find how what voltage a battery is at
and if it's too low it switches to the
next battery it's pretty simple um all
the adinos are except for the third uino
is connected to the Raspberry Pi uh
which provides the environment data to
the pi which runs the td3 algorithm and
I also built this rig out of PVC pipes
cuz one this robot is not indestructible
so yeah um and it also helps it
train uh this is the legs demo
the yeah I the safety minis wouldn't let
me allow it to wouldn't allow me to
power on the thing cuz it's again it's a
ATX power supply from the dump so they
so they wouldn't let me power it on but
there is a video of it working and yeah
that's all you get
[Applause]
all right can can they hear me all right
all right uh so my name is helus and
I've um building the confetti dispenser
part for the project it was supposed to
go on top of the legs but you know
didn't right so we're going to quickly
go through the build of my project so uh
first thing is uh there's a reloading
mechanism which uh would be this thing
if uh it didn't get damaged during
transport uh basically rotates the sh so
that new shells can be loaded in the
chamber and then yeah you're not
propelled hey and then next we have the
controller box which is this thing right
here right it's pretty cool uh there's a
two fans on it and uh one giant uh
switch to turn the power on and off look
on the inside oh and it just fell apart
should be all right hey uh I'm not sure
if you can see it very much looks like a
bomb but I guarantee you it is
not it was uh pretty hard getting that
through
security
yeah now now we have the actual
dispenser unit right so it features two
flyws and a linear actuator to push it
forward so it actually launches and just
doesn't sit there right and for GUI it
is programmed in Python uh which allows
for the controls such as the safety uh
Auto aiming and voice
control oh that was not what happen
okay yeah okay and for joystick aiming I
used the py game library to receive an
input from the Logitech flight stick
which is uh down there cuz there's not
enough room on the table uh it was like
$40 uh some shady website but yeah it it
works though and for the input Supply I
decided to use 12 volts at 2.8 amps for
the flywheel actuator step promotor and
the servo uh I was stuck at uh 12 FS
because my teacher said uh no more than
12 FS so yeah and I would uh fail the
assignment so
yeah all right for the infrared tracking
component uh it's pretty simple I bought
like a infrared light filter off eBay it
was like pretty cheap 40 bux uh the
range is not very good but uh gets the
job done like TW not 20 meters like two
meters that's a bit too much honestly uh
yeah it works by applying a mask over
the point which is detected uh which is
normally red and black because yeah
that's just the color of infrared light
and then we have a Contours The Contours
are like for detecting uh what the parts
actually are I'm not describing it very
well but uh yeah so it creates like a
box and then I can calculate the center
using a bunch of math so and then I
would normally St values between between
negative 1 and one so uh the turret can
aim in its respective Direction like the
asmf and the
elevation right for the GUI it uses the
libraries pame CV2 tter custom tter
numpy n numpy not numpy uh it features
an Aiming display in the top right uh
button controls on the left side and
button controls include Auto aiming
safety and voice control so you can
toggle them on and off and then I've
utilized a multi threading system for
the GUI camera control and voice control
because they all operate at different uh
timings like for the camera it needs to
be like decently fast but not too fast
the GUI who cares it can be like two
frames per second which yeah it works
and controller needs to be as fast as
possible so it actually works and then
voice control cuz it's just on a wild
Loop and it wouldn't work all right so I
have a actual demo here is that sound no
right uh this was uh before I went on
the flight and it still
worked well just me uh testing the
flight stick you know pretty
cool uh it gets jammed on a wise a bit
because I'm not very good at a wire
management Cable
Management right yeah you can uh in the
back you're stuck with wires which I
found out
later it goes up and down you know it's
very
basic me uh questioning why it doesn't
work
here hey any more now uh we'll get to
good part soon trust
me it's long I know it's pretty long but
like will'll get there eventually I I
would skip ahead but I don't know how uh
canva works all right so now it actually
shows you the guy
right for for like0 two seconds but like
I'll show you g
later right let's me uh showing off like
the chamber and the linear actuator that
would push a shell forward I haven't
loaded a shell yet cuz uh there was
still like an assignment video so
yeah all
right was me uh being being a little
stupid and uh didn't notice that it
wasn't
loaded and uh here you go nor normally
there would be like a confetti in there
but uh I didn't load it cuz uh I just
kind of forgot I'll be
honest
yeah know this part uh yeah this the
infrared actual aiming part right so you
see the Red Dot that's like the infrared
light emitted from the flashlight it
automatically uh readjusts uh stops all
inputs from the
joystick right it should go down and
show
you any moment
now hey there
go oh there we go look how cute it
is it's
nodding that's enough of my project and
now we're going to go for uh to Matt
right yeah so I did the voice controls
and the screen for the project overall
um so there were two options for The
Voice Control you could either have it
controlling the confetti launcher or you
could have it as a virtual friend while
controlling the confetti launcher it
would use speech recognition python
Library through the Google speech API
which then looked for your keywords
which are the directions up down left
and right it looked for dispense or it
looked for voice control on or off uh if
you didn't have a voice control on for
the confetti launcher it would go to a
virtual friend which uses a llama 3.2
model to engage in conversation with the
user um uses a python text to speech
library to actually talk back to you so
it's not just text and while it's in
this mode the tracking is done via
helios's infrared system
uh these are just to show the commands
you know up down left right dispense
voice controls uh it was good to have it
be able to turn itself off because then
you know you don't have to go and touch
the GUI um the screen was used for
emotions and to give feedback on the
action so the user knows what they're
doing um you don't really want to be too
close in case it launches at you so
um
yeah so all this was good at least it
was the plan until as my friend Helios
pointed out some things went wrong a
couple quotes we took from about maybe 3
hours ago was one why is this not H
having power two why did it
snap three why is it in inverted and
four three out of the four h Bridges
killed
itself a um okay let's be real um there
are a lot of setbacks for this project
um the first being when you leave your
legs in the car before you go to the
airport in the sun and the plastic 3D
filament ends up melting um here yeah it
was yep um second thing is when the
servo screws end up snapping from being
tight and too tight um kind of a big
setback that's why it's so much bigger
originally um third when airplane
handling may accidentally break part of
your 3D printing um
ouch uh four is when 3 your four h
Bridges blow up and we still don't know
why um and five when the feeding
mechanism ends up
snapping um to start with it was
originally taller and you can see here
in the video that we accidentally filmed
when we accidentally locked our group
member out of the
room um you can see using it uh self-
learning to then try and stand up um it
also used to be able to turn but as you
can probably see here it it no longer
does that
um
yeah and then it also used to show faces
until this uina was in quotes from my
teacher cannibalized to get the last bit
working like the very last part of our
project at least somewhat working um yes
oh
you
um I've been M okay I've been trying my
hardest to uh make this thing be alive
again since like uh 9 in the morning uh
it's very sketchy
uh
like let's see if this uh works today
probably oh that's an
arrow oh
yeah all
right how does this side of the room
feel I noticed some people ducking down
a bit no it should it should be all
right I I should be it should be all
right uh I don't know let's see if that
uh died on the way up to the
stage might might have
died
fortunately so you don't get
splashed all right uh due to unforeseen
circumstances there won't be a life demo
actually
a um and the biggest takeaway is like
what did we learn from this project
[Laughter]
um firstly is don't package things um
unsafely and even if it is safe don't
add an additional packet of wires in the
same
spot um secondly plastic in cars it um
it melts uh we learned that the hard way
uh three contrary to the popular
engineering belief duct tape can't solve
everything um especially not last minute
so uh fourth cooling components is very
important when you don't have enough
resistance or it just generally isn't
cool enough things tend to blow
up um fifth plastic is not that strong
so when you're messing around with it um
it can
snap uh and sixth have spare parts to
make last minute adjustments uh we
didn't have many so um this is the best
we
had thank you very
[Applause]
[Laughter]
[Applause]
much that was amazing okay well I'm a
little bit sad that we weren't shouting
confetti but I am glad that I still have
my
eyesight nothing caught fire we don't
have have to get the uh safety team to
make
a to to worry about our care and then
apologize to the venue that could have
been concerning um we have a few minutes
but not many for some questions so uh
students do you want to all kind of
stand up
and don't crowd around the robot that's
not a great idea let's let's let's kind
of space use some space out here as well
uh let's let's take the robot off the
stage I don't want to touch it I'm sorry
I just got a power supply from the
dump you didn't tell me this earlier
about the yeah no I I I feel like I
learned a lot of things during that talk
and yet I still have more questions at
the end of the talk than than during the
talk pass um
perfect oh yep components it's all right
all we're
good it y yep
[Music]
um
I I look I yeah I'm future me is really
concerned about the risk assessment that
I'm going to have to do next year but um
that's that's future
that's I just like like to say again
these are not my students I don't have
duty of
[Music]
care okay um
so um what questions do we all have also
while while you're thinking up questions
um talking talking about it being
difficult to get this through security
and convince people that it's not a bomb
it's basically a
bomb you're you're setting you're using
exploding conf that like that sounds
like yeah okay maybe that's a
technicality um uh where is the
microphone uh what what people have
questions okay hang on come
down that wasn't a question that was I
can be your that your a question now uh
but we've we've only got one microphone
so we're going to have to run it back
and forth to theud I'm happy to do the
running oh very far thank you Evan just
I need my fitness up today you're
welcome um for vev the bipedal robot
team do you uh after your experience
with robotics and the failures of
mechanics in the real world do you enjoy
it more or
less think think com I'm com com yep yep
this is like a really bad relay okay all
right um is it enjoyable yes I mean uh
is it enjoy enjoyable for my bank
account not really
but uh it was pretty fun I mean it just
took way too long like some librar just
didn't work for some reason I don't know
why yeah staying up till like 2: a.m. to
download a bunch of libraries last
minute was not fun um I think all the
fun engineering Parts was actually
pretty good though probably do it more
from now on if it's
safe I feel like that is a loadbearing
if um are there any other
questions yes why don't you call and I
will repeat your
question question for
Annabelle question for Annabelle did you
think of using I need a better memory
the my God it's been a long day the XML
Library uh rather than Rex um I have not
heard of the XML library before but I
will look into that thank you for the
recommendation
uh a question for the
train let me let me repeat the question
um how long did you have to stand there
for the cargo train I filmed was only uh
2 minutes or so but but but the video
file is like 800 megabytes so it's it's
not small
that is a big
train um yes yes Nick um
the that that was a question of for the
wi-fi hacking was it you who had the
free candy network available earlier
today no that was not me but I want to
know who
did um
um if there are more
questions you can maybe oh there's one
okay yep shout it
out it's a compliment ah a compliment
for Annabelle hang
on hang on hang on this sounds like it
needs the microphone where's the
microphone it's a I know it I know it's
a comment I don't you could you could
phrase your question as a question by
asking everyone by complimenting and
then saying do you agree room and then
we could all
clap um basically for Annabel you know
what she has done is amazing right so I
work with the team you know to develop
applications and we look into the user
interface and you know um user
experience and then that's how in an
application in commercial scale or in
Enterprise scale what we can do is
utilize you know similar logic to
actually give you know look and feel of
what they like and look you know so ask
them to you know upload image you like
and then render the colors you know in
the in the scheme there you know um
based on your logic and that's really
great and so I can see a lot of you know
Brilliant Minds over here so yeah thank
you you know thank you very much
everybody so room do you agree yeah
yeah hey room do you agree that all of
our students are amazing
I do
um okay I will grab some slides out can
I get my co-presenters to give all of
the students a
mug and now I'm going to make the
students act out their own favorite
emoji um
[Laughter]
can we get one more massive Round of
Applause for our fabulous
students put it down go on shoot go done
you're done