►
From YouTube: Apply Machine Learning to GitOps - Ip Sam & Wuxin Zheng, Red HatSpeakers: Ip Sam, Wuxin Zeng
Description
Apply Machine Learning to GitOps - Ip Sam & Wuxin Zheng, Red Hat
Speakers: Ip Sam, Wuxin Zeng
Machine learning involves in very aspect in life. Machine learning helps us make good decisions by learning from the existing data models and applying good predictions of the next output. How can we apply machine learning to GitOps so that we can improve the deployment accuracy and predict which deployments will likely to fail and need more attentions? Can we use machine learning to improve the deployment validation process? Can we use machine learning to improve the existing quality metrics and drive for better deployment results? If you are interested to learn more about how to apply machine learning to GitOps, please attend this meeting.
For more Continuous Delivery Foundation content, check out our blog: https://cd.foundation/blog/
A
A
First
of
all,
what
is
skit
git
is
an
open
source
version
control
system
that
tracks
code
management
changes.
It
applies
changes
to
the
desired
states,
as
version
control
commits
git,
is
a
tool
for
managing
source
code.
It
allows
collaboration
between
developers
by
tracking
changes
in
commit's
history.
A
A
A
This
can
be
achieved
by
integrating
openshift
openshift
is
the
enterprise
ready,
kubernetes
platform
for
managing
containers
and
providing
automation
support
when
we
combine
git
and
devops,
we
get
git
ops,
git
ops
takes
devops
best
practices
for
app
development
and
applies
them
to
infrastructure.
Automation.
A
A
A
A
A
This
graph
here
shows
the
large
tree
of
dependencies,
but
with
machine
learning,
we
can
train
the
system
to
select
the
builds
that
are
most
likely
to
fail
for
a
particular
change.
We
do
that
by
using
a
large
data
set
containing
results
of
packages
on
historical
code
changes
and
then
apply
standard
machine
learning
techniques
during
training.
The
system
learns
from
previous
code
changes
to
come
up
with
the
bill
selection
model.
A
A
The
idea
is
that
we
can
use
historical
data
to
prioritize
artifact
scanning
and
scan
the
artifacts
that's
most
likely
to
fail.
This
allows
us
to
fail
fast
and
recover
fast
as
developers.
We
work
on
large
project
that
has
constant
flows
of
pull
requests.
We
can
apply
machine
learning
to
explore
a
model
to
filter
out
unwanted
prs.
A
A
A
A
A
This
integrator
is
a
boolean
that
indicates
if
the
author
of
the
pr
has
merged
the
pr
before
has
tests
indicates
whether
the
pr
has
tests
which
might
increase
the
chances
of
approval
success
rate
is
the
acceptance
rate
of
the
author's
previous
prs
requested.
Reviewers
indicates
evening
author
requested
any
reviewers
social
con
is
the
number
of
followers
of
the
author
and
lastly,
creative
friday
is
an
interesting
feature.
It
is
possible
that
requests
created
on
friday
are
more
likely
to
not
be
accepted
due
to
the
weekend.
A
As
I
mentioned
before,
we
use
the
etl
process
to
normalize
our
data.
Etl
stands
for
extract,
transform
and
load.
The
process
is
a
set
of
tasks
for
loading
and
normalizing
data,
as
you
can
see
from
the
diagram
first,
it
gets
all
commits
and
fetches
all
pr's
using
rest
api
in
the
end
emerges
all
the
data
to
generate
the
training
data.
A
Machine
learning
is
also
used
in
ide
code
completion.
This
is
an
alternative
to
the
standard
ranking
mechanism.
Machine
learning
can
learn
from
your
interactions
with
co-completion
ui,
to
provide
more
relevant
code
suggestions.
In
this
picture.
We
get
a
glimpse
of
what
is
possible.
With
machine
learning,
assisted
completion.
A
B
Website,
department,
validation,
we
could
also
use
machine
learning
to
do
validation
to
one
against
a
test
on
the
website.
Post
deployment,
validation,
defects,
any
occurrences
that
may
generate
any
dependency
and
deployment
could
return
a
success
status
when
the
defect
was
not
identified
in
the
website.
B
So
this
is
an
example
where
machine
learning
would
be
super
useful
in
terms
of
identifying
whether
the
website
deployment
passed,
the
validation
so
to
do
the
website
validation.
We
basically
created
10
000
different
images
of
the
website
images.
Some
of
them
include
defects
such
as
incorrect
images,
tags
and
layout.
B
The
images
will
be
used
to
train
a
data
model
to
identify
and
discover
defects.
Once
the
model
was
completed,
we
could
use
the
same
model
to
check
for
many
other
copy
of
the
page
and
look
for
defects.
We
leveraged
supervised
learning
algorithm
to
take
a
set
of
training
data
example,
as
training
set.
The
learning
algorithm
is
provided
with
training
data
to
learn
from
the
desire
function.
B
First,
we
need
to
select
the
algorithm.
We
want
to
use
for
learning
and
training
and
then
on
the
left
side
we
have
the
training
data
get
being
fitted
into
the
model
and
on
the
bottom
we
have
the
test
data
that
also
got
feeded
into
the
model
right.
The
output
of
the
model
is
being
used
to
apply
validation,
logic
to
the
surface
on
the
right-hand
side.
First,
we
could
capture
the
entire
web
page
as
an
image
image
then
get
subdivided
into
different
ux
components.
B
The
division
of
the
ux
component
generate
different
training
and
data
set
and
test
data
set
to
feed
the
model.
With
the
model
we
can
test
any
new
ux
component
across
the
browser,
with
different
resolution,
different
dimensions
by
feeding
the
image
of
the
ux
component
to
the
model.
The
model
classify
if
the
ux
model
component
pass
the
desired
qualification
criteria.
This
is
the
process
of
making
a
decision
of
a
particular
image
based
on
a
specific
class
is
called
classification.
B
So
this
is
an
image
website.
We
take
a
image
of
the
entire
site
and
then
the
second
step.
We
do
different
segmentation,
you
have
the
header,
you
have
the
body,
you
have
the
footer,
you
have
the
main
scroll
bar
and
so
on.
Right.
All
these
different
segmented
images
will
get
feeded
into
the
new
network
on
the
third
box
in
the
middle
and
then
at
the
same
time,
historical
data
of
the
10
000
images
will
also
get
feeded
into
the
neural
network.
As
a
training
set,
you
will
make
a
decision
based
on
probability.
B
It
will
say
whether
the
website
deployment
pass
or
fail
the
validation
step.
So
each
image
was
classified
with
a
score
between
0
to
1.
score
closer
to
0,
meaning
that
the
model
predicts
a
potential
test
case.
Failure
such
as
a
ui
defect,
a
score
closer
to
1,
meaning
the
preparation
of
a
test
case
meeting
is
qualification
criteria
and
we
need
to
set
up
a
cut
off
threshold.
Any
value
there
were
lower
than
the
threshold
is
going
to
be
predicted
as
a
defect.
B
These
are
some
of
the
smaller
images
that
got
captured
by
the
model
and
you
can
see
each
image
have
a
different
classification
and,
furthermore,
each
classification
will
make
some
sort
of
prediction
of
the
image
whether
this
is
a
defect
or
not.
If
this
is
a
defect,
what
type
of
defect?
What
is
the
severity
of
the
defects,
alert
and
monitoring
is
another
main
concept
in
git
ops.
We
want
the
devops
engineer
to
get
alert
when
production
issues
happen,
but
oftentimes
the
production
issue
happened
too
late
when
the
alert
will
trigger
production.
Autos
has
occurred.
B
This
is
too
late.
Engineers
are
reacting
to
the
issue
and
it
happened
by
monitoring
with
early
detection.
We
could
identify
simple
production
issues
such
as
disk
space,
using
prometheus
alert
manager
to
report
the
problem
we
could
predict
when
problem
would
likely
to
happen,
and
we
could
use
that
to
notify
production,
team
and
production
engineer
to
look
at.
So
this
is
a
graph.
You
can
monitor
the
disk
usage
of
one
of
the
production
server.
Different
data
points
at
different
time
and
different
time
frame
using.
A
B
Learning
we
could
predict
the
trend
of
the
usages,
as
shown
in
the
blue
line,
and
we
could
potentially
say
this
usage
is
going
to
happen
within
one
hour.
So
this
is
an
example
of
a
predictive
disk
outage.
This
outage
make
adjustment
to
the
algorithm
in
production.
The
result
got
feeded
back
into
the
program
for
analysis:
how
to
apply
its
rules
based
on
the
rule
that
it
has
worked
on
from
the
past.
B
As
you
guys
know,
the
predictive
analysis
always
starts
with
two
steps.
First,
you
get
the
historical
data
you
apply
to
some
predictive
algorithm
and
you
generate
a
model
and
you
use
the
new
data
that
coming
from
production
applied
to
the
same
model
again-
and
this
is
getting
your
prediction:
how
could
we
do
regression
testing
using
information
extracted
from
the
view
metadata
to
detect
which
test
to
onenote
for
a
particular
code
base
and
how
to
prioritize
this
test?
Based
on
the
prediction?
Because
we
believe
you
know
each
test
is
a
little
bit
different.
B
Some
tests
are
more
important.
Some
are
less
important
by
analyzing
the
bill
dependency.
We
can
find
the
test
that
less
dependent
and
find
the
tests
that
are
more
dependent.
If
you
change
one
of
the
lower
level
library,
we
don't
need
to
run
all
the
tests
in
sequential
order.
We
can
run
the
tests
that
are
more
important
and
if
any
one
of
these
tests
fail,
we
can
do
an
abortion
and
fill
out
the
test
pipeline.
B
This
is
a
dependent
tree
that
we
are
showing
source
file
at
lowest
level
right.
This
is
the
source
file
that
were
developed
by
developer
and
then
in
the
middle.
You
have
some
intermediate
module
that
we're
using
this
different
source
file,
and
on
top
of
that
you
have
different
tests.
Each
test
could
be
a
unit
test
could
be
an
integration
test.
They
could
be
testing
different
code
paths,
testing,
different
components,
testing
different
integration
points
as
one
two,
three
four
and
five
six
six
different
tests
and
traditional
regression
testing.
B
You
need
to
test
all
tests
in
a
sequential
order.
So
let's
see
how
we
could
use
machine
learning
to
improve
this
process.
The
machine
learning
will
predict
the
probability
that
a
given
test
find
a
regression
with
a
particular
code
change.
It
will
make
informed
decision
to
rule
out
tests
that
are
extremely
unlikely
to
cover
an
issue.
It
would
open
up
a
new
and
more
efficient
way
of
selecting
tests
based
on
priority.
Let's
say
you
have
used
a
large
data
set
that
contains
different
test
results
from
the
historical
code
base.
B
We
can
apply
to
the
existing
machine
learning
model
to
make
the
prediction
we
have
the
training
on
the
top.
We
have
historical
code
change
inverted
test.
Then
we
could
apply
that
to
make
a
cause
of
fail
prediction
based
on
that,
we
would
come
up
with
the
selection
model.
Once
you
have
the
selection
model,
we
could
use
that
for
making
the
prediction
with
the
new
code
change
with
the
test
coming
in,
we
would
apply
the
test
selection
model
and
that
will
generate
the
probability
of
a
failure
for
each
single
test.
B
B
With
this
technique,
we
could
find
and
assign
the
probability
of
finding
a
defect
to
each
specific
test.
The
test
one
has
a
probability
of
99
which
is
really
high
and
then
test.
Two
only
have
a
nine
percent
test.
Three
has
a
thirty
two
percent
and
test
four
has
a
fourteen
percent,
and
so
on
right.
You
can
recursively,
apply
the
same
model
and
do
the
prediction
for
each
test.
B
So
in
this
situation
we
would
execute
test
one
and
test
three
first,
and
also
we
need
to
deal
with
a
lot
of
unstable
tests
when
the
test
was
not
generating
result
constantly
by
some
test
will
pass
and
fail
unpredictably
based
on
timing
based
on
dependency
based
on
data
data
source.
Those
tests
would
not
be
good
to
use
for
doing
the
predictability.
In
this
case,
you
need
to
segregate
out
unstable
tests.
If
you
do
that,
you
would
be
able
to
generate
a
more
consistent
outcome.
B
Deploying
non-deterministic
application
also
require
machine
learning.
We
need
to
evaluate
the
quality
and
risk
of
the
latest
deployment
and
evaluate
the
deployment
according
to
acceptance
criteria.
We
need
to
prepare
to
support
those
assertions
in
a
statistical
manner.
If
you
are
searching
or
sweat
force,
but
it
may
not
be
always
true
or
always
false,
so
you
need
to
do
it
in
a
statistical
way
and
the
confidence
percentage
of
the
deployment
will
produce
an
answer
in
a
different
range.
B
B
So
in
this
meeting
we
have
covered
a
lot
of
application
using
machine
learning
and
how
machine
learning
could
be
used
to
improve
the
efficiency
of
the
git
ops
life
cycle.
We
could
use
machine
learning
to
make
evaluation
and
prediction
quickly
and
if
there's
a
defect,
we
can
use
machine
learning
to
fix
them
and
we
fix
the
code
and
we
enter
the
code
back
to
the
cicd
pipeline.
Machine
learning
also
eliminated
the
unnecessary
computational
resources
and
capacity
when
ml
predicted
the
deployment
is
going
to
fail.
B
We
don't
need
to
wait
until
the
end
way
for
a
failure,
so
it
also
solves
some
of
the
limitations.
Many
organizations
are
facing
in
terms
of
how
to
shorten
the
release
cycle
and
fail
fast
and
save
fast.
When
the
deployment
results
are
dynamically
changing,
we
could
use
machine
learning
to
make
the
best
decision
and
addiction
of
the
outcome.
Thank
you
again
attending
this
meeting.
It
was
a
pleasure
talking
to
you.
If
you
have
any
questions,
please
reach
out
to
the
red
hat
consulting
team.
Thank
you.