In the world of Devops and SRE, GitHub is one of the most popular buzzword and you’ve most probably came across it on a git repository. In this beginner-friendly article for Devops folks, we are going to have our hands on GitHub Actions, learn what it is and use an action on a workflow.

Before we go any further, we need to define some key terms which are components of GitHub Actions.

Workflows

A workflow is an automated process that is made up of one or more multiple jobs and can be triggered by an event. Workflows are defined and configured in YAML(Yet Another Markup Language) file in the .github/workflows directory of your repository.

Actions

Actions are the building blocks of a workflow, they are automated processes which can combine to create a job.

Jobs

A job is a collection of workflow stages that executes in an orderly way and under the same runner. A job’s dependencies can be configured with other jobs and when a job takes another job’s dependencies, it will wait for the dependent job to complete before it can run… Each step in a job can either be a shell script or an action that will be executed.

Runners

A runner is a server that runs your workflows when they are triggered. Because each runner is limited to one job at a time, it waits for available jobs to execute and then runs the job’s actions and returns the results back to GitHub. Runners can either be hosted on GitHub or Self hosted on your own servers.

Step

A step is a set of tasks that can be executed by a job, it has the ability to run actions.

What are GitHub Actions

GitHub Actions is a CI/CD platform that allows you to automate your build, test and deployment pipeline with ease. GitHub Actions gives super-powers to your repo, imagine running a workflow that automatically creates labels whenever someone creates a new issue in your repository or when a pull request is made to your repository, an automated workflow can check if the pull request is eligible for merging into the main code or not. With GitHub Actions, when you code and push your project to GitHub, you can build a script to test every time you commit a change or someone creates a pull request and if any exception occurs, GitHub Actions will fail the build and prevent it from being merged.

You can create your own actions or use and customize actions or shared by the GitHub community. When developing an action for the public, storing an action in its own repository makes it easier for the GitHub community to discover the action and make contributions to it but if you don’t want to make it available to others, you can store the action in any location in your repository.

Types of Actions

There are two main types of publishable actions: JavaScript and Docker actions

Docker actions package an environment with GitHub Actions code as it provides reliable unit work. JavaScript actions are easier to write and faster than docker actions because they run directly on the runner machine and don’t have to worry about rebuilding the docker image at every instance.

Another type of action is Composite Run Steps, which helps you reuse code inside your project workflows and hides complexity when you don’t want to publish your action to the marketplace.

Creating a composite action

In this short tutorial, we will be creating our first GitHub Action together. We will create a composite action which you can use from one repository to another

Start by creating a public repo in GitHub and choose any name for the repository

clone your repo to your computer and from your terminal, change into the cloned directory

cd composite-action-hello

In your repository, create a new file called hello.sh and add the code example:

echo Hello world

From your terminal, make hello.sh executable.

chmod +x hello.sh

From your terminal add your bash file

git add hello.sh
git commit -m “Added hello script”
git push

Let’s create an action metadata file with the details below:

name: 'Hello World'
description: 'Greet someone'
inputs:
who-to-greet: # id of input
description: 'Who to greet'
required: true
default: 'World'
outputs:
random-number:
description: "Random number"
value: ${{ steps.random-number-generator.outputs.random-id }}
runs:
using: "composite"
steps:
- run: echo Hello ${{ inputs.who-to-greet }}.
shell: bash
- id: random-number-generator
run: echo "::set-output name=random-id::$(echo $RANDOM)"
shell: bash
- run: echo "${{ github.action_path }}" >> $GITHUB_PATH
shell: bash 
- run: hello.sh
shell: bash

From your terminal check in your action.yaml file

git add action.yaml
git commit -m “Added action file”
git push

From your terminal, add a tag.

git tag -a -m “First release ” v1
git push --follow-tags

Your repository should look like this

It is done 🎉!!

To test this action, create an empty action file in another repository, copy the workflow code into a .github/workflows/main.yml file but replace actions/composite-action-hello@v1 with the new repo and tag you created. From your repository, click Actions tab and select the latest workflow run...

As you can see, we easily created a composite action which sends us our Hello World greeting! Thanks for reading

You can check the repo for here

Artificial Intelligence is building smart machines that can be able to think like humans and mimics their actions to solve complex problems. AI is used in the healthcare industry for faster and better diagnosis of diseases in lesser time than doctors, AI is also used in the transport industry with the emergence of self-driving cars, the creative and entertainment industry also use AI, as companies like Netflix and Disney use AI in their movie recommendation systems. Deep learning is a class of machine learning algorithms that uses multiple layers to progressively extract higher-level features from the raw input, it is an AI function that imitates the workings of the human brain in processing data and creating patterns for use in decision making utilizes structured and unstructured data, it structures algorithms in layers to create an artificial neural network that can learn and make intelligent unsupervised decisions. A practical example of deep learning is face recognition as it employs layers of neural networks that have been trained.

WHAT ARE GANs?

GANs(Generative adversarial networks) are used in generative modelling using deep learning methods like in convolutional neural networks. Generative modelling is an unsupervised learning task in ML that involves automatically discovering and learning patterns in data inputs in a way that the model can be used to generate or output new examples that could have been drawn from the original dataset. GANs make generative models to be able to generate realistic examples across a range of problem domains, most notably in image-to-image translation and generating realistic photos of objects and people, it can also generate realistic 3D models, videos and more. Yann LeChun, one of the fathers of deep learning said that “GAN is the coolest idea of ML in the last 20 years”

HOW DO GANs WORK?

A GAN can be trained to generate images from random noises. For example, we can train a GAN to generate digit images that look like hand-written digit images from the MNIST database. GANs generally has two parts in them, the generator and the discriminator. The generator creates the images while the discriminator classifies the images into real and fake. The generator training makes use of a bridge between the generator and the discriminator.

Neural networks work with inputs, we input data that we want, maybe to classify or make a prediction, but GANs always outputs entirely new data instances so GANs take in random noises as inputs, the generator then transforms this noise into meaningful output. With noise, GAN can produce a wide variety of data, sampling from different places in the target distribution. Experiments suggest that the distribution of the noise doesn’t matter much, so we can choose something that is easy to sample from, as a uniform distribution. For convenience, the space from which the noise is sampled is usually of a smaller dimension than the dimensionality of the output space.

In training a neural network, we alter the network’s weight to reduce the loss of its output. The generator feeds into the discriminator and the discriminator produces the output we’re trying to affect. The generator loss penalizes the generator for producing a sample that the discriminator network.

VISUALIZING A SONG

As a visualizer plays a song file, it reads the audio data in very short time slices (usually less than 20 milliseconds). The visualizer does a Fourier transform on each slice, extracting the frequency components, and updates the visual display using the frequency information. An example is the Audiomack app visualizer. How the visual display is updated in response to the frequency info is up to the programmer. Generally, the graphics methods have to be extremely fast and lightweight in order to update the visuals in time with the music (and not bog down the PC). In the early days (and still), visualizers often modified the colour palette in Windows directly to achieve some pretty cool effects. One characteristic of frequency-component-based visualizers is that they don’t often seem to respond to the “beats” of music (like percussion hits, for example) very well. More interesting and responsive visualizers can be written that combine the frequency-domain information with an awareness of “spikes” in the audio that often correspond to percussion hits.

THE DEEP MUSIC VISUALIZER AND BigGAN

BigGAN is a new technology from the GANs family, BigGAN was created in 2018 at Google by Brock et al. BigGAN is considered big because it contains over 300million parameters trained on hundreds of google TPUs at the estimated cost of $60,000 and the result of this is an AI model that generates images from 1128 input parameters. Here, interpolation between classes without changing the noise vector reveals shared features in the latent space like faces, interpolating between random vectors reveals deeper structures. Apps like artbreeder have provided simple interfaces for creating AI artworks. The deep music visualizer was built by Matt Siegelman, it is an open-source tool for navigating the latent space with sound. To use the deep music visualizer, one will first have to clone the GitHub repo and follow the installation guide at %[http://github.com/msieg/deep-music-visualizer]. This requires your python programming skills Then run this command at the directory in your terminal:

python visualize.py — song theNameOfUrSong.mp3

Note: Use the name of the song you want to visualize, having the .mp3 extension.

The deep music visualizer syncs pitch with the class vector, volume and tempo with the noise vector, so that pitch controls the objects, shapes and texture in each frame, while volume and tempo control movement between frames. At each time point in the song, a chromagram of the twelve chromatic notes determines the weights of up to 12 ImageNet classes in the class vector. BigGAN is big and slow, running a program on a normal laptop will take about 8hours to run. But with a resolution of 128x128, It should take about 25minutes and to run on a 128 by 128 resolution, you can use the command:

python visualize.py — song theNameOfUrSong.mp3 — resolution 128

But one can, however, generate high-resolution images/videos by launching a virtual GPU on Google Cloud to speed up runtime from 8hours to a few minutes, but the virtual GPU isn’t free and costs $1/hour but Google awards new users with $300 in credit. Talking about video durations, it can be useful to generate shorter videos to limit runtime while testing some other input parameters. The pitch sensitivity is the sensitivity of the class vector to changes in pitch. At higher pitch sensitivity, the shapes, textures and objects in the video change more rapidly and adhere more precisely to the notes in the music. The tempo sensitivity is the sensitivity of the noise vector to changes in volume and tempo. Higher tempo sensitivity yields more movement.

Picture Examples of visualized songs

Follow me 🤭 I’m on Twitter

I'm actually so happy to join the fun train, the HNGi8 is where I look forward to growing as a backend developer and learn about working with teams. I'm already in love with the whole setting and of course the networking and the #pepperdem humor channel 😂

My internship goals within the end of 8 weeks

• To be challenged and learn from it: I believe that everyone needs to be challenged one way or the other so as to bring the best out of one, and the tasks put up have seem to be those that will challenge ones critical thinking and agility as a software developer.

• To network and meet new people: It's a thing of joy when you meet people who share same interest as you do and HNG has made it possible to meet people of different diversities from all over Africa.

• Collaborate and make team-mates: I am so passionate about working with people and collaborating to solve problems together with them and I believe that helps increase the productivity and team-spirit between individuals

• Sail through to the final stage of the internship and get that HNGi8 T-shirt. For more info on HNG zuri internships, visit Zuri.team

Below are some tutorial resources to get you started on

• Figma: Figma is a design platform for teams who build products together. Born on the Web, Figma helps the entire product team create, test, and ship better designs.

• Git: Git is software for tracking changes in any set of files, usually used for coordinating work among programmers collaboratively developing source code during software development

• HTML: HyperText Markup Language, or HTML is the standard markup language for documents designed to be displayed in a web browser. It can be assisted by technologies such as Cascading Style Sheets and scripting languages such as JavaScript

• Golang: Go is a statically typed, compiled programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. Go is syntactically similar to C, but with memory safety, garbage collection, structural typing, and CSP-style concurrency