Neural Networks made ridiculously simple

Welcome

• this session is 🌶 - a beginner-friendly introduction
• we’ll get going properly at 13.05
• if you can’t access the chat, you might need to join our Teams channel: tinyurl.com/kindnetwork
• you can find session materials at tinyurl.com/kindtrp

The KIND network

• a social learning space for staff working with knowledge, information, and data across health, social care, and housing in Scotland
• we offer social support, free training, mentoring, community events, …
• Teams channel / mailing list

KIND training sessions

What’s this session for?

• neural nets are a core technology for AI/ML systems
• they’ve been around for decades (and probably will go on for decades)
• they’re also particularly helpful for health & care folk as a way of understanding AI/ML tools in general

What this session won’t do

• give a general introduction to AI/ML
• explain how to build a neural net of your very own
• discuss in any detail the (often formidable) maths of neural nets

Biology: the neurone

Biology: activation

Biology: networks of neurones

Machines: the node

Here’s a simple representation of a node, implemented in code, that we might find in a neural network:

Machines: activation functions

bit of code - nothing fancy!

node <- function(input){
  !input
}

node(TRUE)

Machines: networks of nodes

Machines: networks of nodes

• nodes are usually found in networks
• can produce complex and sophisticated behaviours in a robust way
  
• non-obvious relationship between structure and function in artifical neural networks (ANN)

Several kinds of networks

• there are lots of ways that neural networks can be arranged
• our example above = feed-forward
  • all the nodes are connected from left-to-right
• but more complex architectures - like recurrent neural networks - might have feedback looks and other biological-ish features
• different numbers of layers
• lots of different design tendencies since the first intro of neural nets in the 1950s (Rosenblatt 1958)
• most fancy ANNs are currently architecturally simple

Why ANNs?

• ANNs can can potentially replicate any input-output ransformation
• we do that by a) increasing complexity and b) allowing them to ‘learn’

Different activation functions

• binary (true/false)
• continuous
  • linear
  • non-linear (like sigmoid, ReLU)

Training in neural networks

• ANNs can be trained
  • take a dataset
  • split it into training and test parts
    • classify (by hand) the training data
  • then train
    • feed your ANN the training data and evaluate how well it performs
    • modify the ANN based on that evaluation
    • repeat until done/bored/perfect
  • finally, test your model with your unlabelled test data and evaluate

MNIST

• a classic dataset
  
• recognizing handwritten numbers = actually-important task
• 60000 labelled training images
• 10000 test images
• each is a 28*28 pixel matrix grey values encoded as 0-255

MNIST data example

Train for MNIST

• take your training data
• put together a neural network (number of nodes, layers, feedback, activation functions)
• run the training data, and evaluate based on labelling
• modify your neural network, rinse, and repeat
• …
• when happy, try the unlabelled test data

MNIST examples

• lots of different examples
• why do this?

MNIST in R

An aside here for the R enthusiasts - we can plot the handwritten numbers back out of the data using ggplot():

mnist_plot_dat <- function(df) {
   # matrix to pivoted tibble for plotting
  df |>
      as_tibble() |>
      mutate(rn = row_number()) |>
      pivot_longer(!rn) |>
      mutate(name = as.numeric(gsub("V", "", name)))
}

mnist_main_plot <- function(df) {
  df |>
    ggplot() +
    geom_tile(aes(
      x = rn,
      y = reorder(name,-name),
      fill = value
    )) +
    scale_fill_gradient2(mid = "white", high = "black")
}

mnist_plot <- function(n){

  mnist_plot_dat(matrix(mnist$train$images[n, ], 28, 28)) |>
    mnist_main_plot() +
      ggtitle(glue("Label: { mnist$train$labels[n]}")) +
      theme_void() +
      theme(legend.position = "none")
    
    # matrix(mnist$train$images[n, ], 28, 28) |>
    #   as_tibble() |>
    #   mutate(rn = row_number()) |>
    #   pivot_longer(!rn) |>
    #   mutate(name = as.numeric(gsub("V", "", name))) |>
    #   ggplot() +
    #   geom_tile(aes(
    #     x = rn,
    #     y = reorder(name,-name),
    #     fill = value
    #   )) +
    #   scale_fill_gradient2(mid = "white", high = "black") +
    #   ggtitle(glue("Label: { mnist$train$labels[n]}")) +
    #   theme_void() +
    #   theme(legend.position = "none")

}

#mnist_plot_dat(matrix(mnist$train$images[1:36, ], 28, 28))

gridExtra::grid.arrange(grobs = map(1:36, mnist_plot), nrow = 6, top="Some MNIST examples")