#C Program to Represent Graph Using Adjacency Matrix

[codezclub]

Write a C Program for Creation of Adjacency Matrix

Creation of Adjacency Matrix Write a C Program for Creation of Adjacency Matrix. Here’s simple Program for adjacency matrix representation of graph in data structure in C Programming Language. Adjacency Matrix:  Adjacency Matrix is a 2D array of size V x V where V is the number of vertices in a graph. Let the 2D array be adj[][], a slot adj[i][j] = 1 indicates that there is an edge from vertex i…

[sciforce]

Understanding Tensor Processing Units

In 2017, Google announced a Tensor Processing Unit (TPU) — a custom application-specific integrated circuit (ASIC) built specifically for machine learning. A year later, TPUs were moved to the cloud and made open for commercial use.

Following the line of CPUs and GPUs, Tensor Processing Units (TPUs) are Google’s custom-developed application-specific integrated circuits (ASICs) that are supposed to accelerate machine learning workloads. They are designed specifically for Google’s TensorFlow framework, a symbolic math library that is used for neural networks.

TensorFlow is known to be not an easy nut to crack. To ensure a better understanding of the concept of a tensor, the TPU structure and how it works, we’ll try to give a brief and simple overview of the technology.

What is a tensor?

In mathematics, a tensor is a geometric object that maps geometric vectors, scalars, and other similar objects in a multi-linear manner to a resulting tensor. This may sound quite confusing, but in simpler words, a tensor is a generalized matrix that could be a 1-D matrix (a vector), a 3-D matrix (a cube of numbers), even a 0-D matrix (a single number), or a higher dimensional structure that is harder to visualize. The dimension of the tensor is called its rank.

An important characteristic of a tensor is its dynamics: it lives in a structure and interacts with other mathematical entities. If one transforms other entities in the structure in a regular way, the tensor obeys a related transformation rule and its numerical values shirt around along with the other entities. This “dynamical” property of a tensor is the key that distinguishes it from a mere matrix.

In computer science, a Tensor is an n-dimensional matrix analogous to a Numpy array — the fundamental data structure used by machine learning algorithms. It is the basic unit of operation in with TensorFlow and in fact uses Numpy.

What does it have to do with Machine Learning?

The math involved in doing ML includes adding and multiplying these objects:

scalar

vector

matrix

Let’s have a look at a simple neural network. The following example on the TensorFlow Playground trains a neural network to classify a data point as blue or orange based on a training dataset:

The trained neural network classifies data with labels or estimates missing or future values in the task called inference. For this, each neuron in a neural network undergoes the following calculations:

Multiply the input data (x) with weights (w) to represent the signal strength;

Add the results to aggregate the neuron’s state;

Apply an activation function (f) to modulate the artificial neuron’s activity.

As you can see, with three inputs and only two neurons with a fully connected single-layer neural network, you have to execute six multiplications between the weights and inputs and add up the multiplications in two groups of three. This sequence of multiplications and additions can be written as a matrix multiplication and is the most computationally intensive part of running a trained model. Every single prediction requires many steps of multiplying processed input data by a weight matrix and applying an activation function.

As a result, multiplying and taking slices from arrays takes a lot of CPU clock cycles and memory. TPUs were designed to relieve these specific workloads.

Logic behind TPU

To simplify the process of neural network training, TPUs address this issue in several directions:

1. Quantization

In line with the quantization technique, the process of approximation of an arbitrary value between a preset minimum and a maximum value with an 8-bit integer, TPUs contain 65,536 8-bit integer multipliers. In essence, this technique is compression of floating point calculations with 32-bit or even 16-bit numbers to 8-it integers. As you can see, the continuous large set of values (such as the real numbers) is converted to a discrete set (of integers) with maintaining the curve:

Quantization is the first powerful tool TPUs use to reduce the cost of neural network predictions without significant losses in accuracy.

2. Focus on inference maths

Secondly, the TPU design itself encapsulates the essence of neural network calculation. A TPU includes the following computational resources:

Matrix Multiplier Unit (MXU): 65,536 8-bit multiply-and-add units for matrix operations;

Unified Buffer (UB): 24MB of SRAM that work as registers;

Activation Unit (AU): Hardwired activation functions.

They are controlled with a dozen high-level instructions that focus on the major mathematical operations required for neural network inference. A special compiler and software stack translate API calls from TensorFlow graphs into TPU instructions.

3. Parallel Processing

Typical RISC processors provide instructions for simple calculations such as multiplying by processing a single, or scalar, operation with each instruction. As you remember, a TPU contains a Matrix Multiplier Unit. It is designed as a matrix, rather than scalar, processor and processes hundreds of thousands of operations (= matrix operation) in a single clock cycle. Using such a matrix processor is like printing documents a whole page at a time rather than character-by-character or line-by-line.

4. A systolic array

The heart of the TPU is the new architecture of the MXU called a systolic array. In traditional architectures (such as CPUs or GPUs), values are stored in registers, and a program tells the Arithmetic Logic Units (ALUs) which registers to read, the operation to perform (such as an addition, multiplication or logical AND) and the register into which to put the result. A program consists of a sequence of these operations. In an MXU, matrix multiplication reuses inputs many times to procduce the final output. A value is read once but used for many different operations without storing it back to a register. The ALUs perform only multiplications and additions in fixed patterns, and wires connect adjacent ALUs, which makes them short and energy-efficient.

To understand this design, think of the heart pumping blood — like the data flowing through the chip in waves.

Going Cloud

Probably, the most exciting part about TPUs is that Google has made these chips available as a service on the Google Cloud Platform and shared its technology. Cloud TPU allows running machine learning workloads on Google’s TPU accelerator hardware using TensorFlow. The TPU workload is then distributed to the TPU Cloud Server, as shown below:

Cloud TPU is designed to help researchers, developers, and businesses to build TensorFlow compute clusters that can leverage CPUs, GPUs, and TPUs. High-level Tensorflow APIs help you to get models running on the Cloud TPU hardware.

Programming model

Transferring data between Cloud TPU and host memory is slow compared to the speed of computation because of the speed of the PCIe bus. Due to constant ‘ping-pongs’ between host and Cloud TPU, the latter is idle most of time, waiting for data to arrive over the PCIe bus. To enhance efficiency, the programming model for Cloud TPU shifts much of the training to the TPU. In this way:

All model parameters are kept in on-chip high bandwidth memory;

Many training steps are executed in a loop amortizing the cost of launching computations on Cloud TPU;

The TensorFlow server fetches and pre-processes data before “infeeding” to the Cloud TPU hardware;

Cores on a Cloud TPU synchronously execute an identical program that is stored in their own respective HBM.

Pricing

According to Google’s pricing information, each TPU cost $4.50 hour. The rates do not differ for the three TPU models shown on the website. That seems confusing as TPUs have different memory sizes and clock speeds.

CPUs/GPUs/TPUs Contrasted

CPUs (Central Processing Units) and GPUs (Graphics Processing Units) compute most ML problems but at the same time they consume a lot of time. Some experts contemplate that TPUs are essentially the NVidia’s GPUs moved to cloud. Since the technologies are quite similar, we offer a table contrasting the CPU, GPU and TPU chips to show how they differ and what their scopes of application are:

Advantages of TPU

Using TPUs offers a number of advantages in terms of increasing efficiency and speed of computation, including the following benefits:

Accelerated performance of linear algebra computation, which is used heavily in machine learning applications.

Minimized time-to-accuracy when training large, complex neural network models: models that previously took weeks to train can converge in hours on TPUs.

Scalable operations across different machines with their TPU servers.

TPU Limitations

An important thing to understand is that TPUs are specifically optimized to perform fast, bulky matrix multiplication. Cloud TPUs are likely to be outperformed by other platforms in workloads that are not dominated by matrix multiplication, such as:

Linear algebra programs that require frequent branching or are dominated element-wise by algebra;

Workloads that access memory in a sparse manner;

Workloads that require high-precision arithmetic;

Neural network workloads that contain custom TensorFlow operations written in C++, specifically, custom operations in the body of the main training loop.

The combination of TensorFlow and TPUs can work wonders in the field of medicine, image processing and ML. When the time to train a model and the computation time are reduced from weeks to hours, machine learning becomes more competitive and available to the broader public. Besides, offering TPUs as a service on Cloud allows users to start building their models without the need of up-front capital investment. This means that researchers, engineers, small businesses and even students can start machine learning projects with ease.

[felord]

FIT1045 Algorithms and programming in Python, S2 Assignment 1 Solved

Objectives

The objectives of this assignment are: To demonstrate the ability to implement algorithms using basic data structures and operations on them. To gain experience in designing an algorithm for a given problem description and implementing that algorithm in Python.

Submission Procedure

Save your files into a zip file called yourStudentID yourFirstName yourLastName.zip Submit your zip file containing your solution to Moodle. Your assignment will not be accepted unless it is a readable zip file. Important Note: Please ensure that you have read and understood the university’s policies on plagiarism and collusion available at http://www.monash.edu.au/students/policies/academic-integrity.html. You will be required to agree to these policies when you submit your assignment. A common mistake students make is to use Google to find solutions to the questions. Once you have seen a solution it is often difficult to come up with your own version. The best way to avoid making this mistake is to avoid using Google. You have been given all the tools you need in workshops. If you find you are stuck, feel free to ask for assistance on Moodle, ensuring that you do not post your code. Marks: This assignment will be marked both by the correctness of your code and by an interview with your lab demonstrator, to assess your understanding. This means that although the quality of your code (commenting, decomposition, good variable names etc.) will not be marked directly, it will help to write clean code so that it is easier for you to understand and explain. This assignment has a total of 12 marks and contributes to 10% of your final mark. For each day an assignment is late, the maximum achievable mark is reduced by 10% of the total. For example, if the assignment is late by 3 days (including weekends), the highest achievable mark is 70% of 12, which is 8.4. Assignments submitted 7 days after the due date will normally not be accepted. Detailed marking guides can be found at the end of each task. Marks are subtracted when you are unable to explain your code via a code walk-through in the assessment interview. Readable code is the basis of a convincing code walk-through.

Task 1: Strings (3.5 Marks)

Create a Python module called strings.py. Within this module implement the following three tasks. For this module you may not use the Python sequence method s.count(x). You may not import any other libraries or modules.

Part A: Code Breaker (1 Mark)

Write a function decode(string, n) that takes in an encoded message as a string and returns the decoded message. Input: a string string and a positive integer n. Output: the decoded string. The string is decoded by discarding the first n characters from the input string, keeping the next n characters, discarding the next n characters, and so on, until the input string is exhausted. There is no guarantee at which point in the decoding (keep or discard) the string will be exhausted. There is no guarantee that the length of string will be a multiple of n. Examples Calling decode(‘#P#y#t#h#o#n#’, 1) returns ‘Python’. Calling decode(‘AxYLet1x3’s T74codaa7e!’, 3) returns ‘Let’s code!’.

Part B: Pattern Finder (1 Mark)

Write a function pattern count(string, pat) that counts how many times a pattern occurs within a text. Input: a string string and a non-empty string pat, both comprising both upper and lower case alphanumeric and non-alphanumeric characters. Output: an integer count of the number of times pat occurs within string. The count is case sensitive. (See Example c.) Examples Calling pattern count(‘bcabcabca’, ‘abc’) returns 2. Calling pattern count(‘aaaa’, ‘aa’) returns 3. Calling pattern count(‘A long time ago in a galaxy far, far away...’, ‘a’) returns 8. Calling pattern count(‘If you must blink, do it now.’, ‘code’) returns 0.

Part C: Palindromes (1.5 Marks)

A palindrome is a word, phrase, or sequence that reads the same backwards as forwards. Write a function palindrome(string) that determines whether or not a given string is a palindrome. In order to receive full marks, the function must determine whether the alphanumerical characters create a palindrome (see Examples). Input: a string string comprising both upper and lower case alphanumeric and non-alphanumeric characters. Output: a boolean, True if the string when converted to lower case alphanumeric characters is a palindrome; otherwise False. Examples Calling palindrome(‘RacecaR’) returns True because ‘RacecaR’ reads the same backwards as forwards. Calling palindrome(‘66racecar77’) returns False because ‘66racecar77’ does not read the same backwards as forwards. Calling palindrome(‘Racecar’) returns True because ‘racecar’ reads the same backwards as forwards. Calling palindrome(‘Madam, I’m Adam’) returns True because ‘madamimadam’ reads the same backwards as forwards. Calling palindrome(‘#4Satire: Veritas4’) returns True because ‘4satireveritas4’ reads the same backwards as forwards.

Marking Guide (total 3.5 marks)

Marks are given for the correct behavior of the different functions: 1 mark for decode. 1 mark for pattern count. 5 marks if palindrome can correctly identify that a string with no processing is a palindrome (see Examples a and b), 1.5 marks if palindrome can correctly identify that a string when converted to lower case alphanumeric characters is a palindrome (see Examples c, d, and e).

Task 2: Friends (4.5 Marks)

You have been employed by Monash to analyse friendship groups on campus. Individuals have been allocated a number between 0 and the number of people on campus (minus one), and their friendships have been recorded as edges between numbered vertices. We assume friendships are always bi-directional. Monash has implemented this graph in a Python-readable format as both an adjacency matrix and an adjacency list. Create a Python module called friends.py. Within this module implement the following three tasks. Ensure you follow the inputs for each function correctly - one function takes an adjacency list, two functions take an adjacency matrix. You may not import any other libraries or modules.

Part A: Popular (1.5 Marks)

Write a function popular(graph list, n) that returns a list of people who have at least n friends. Each person is identified by the number of their vertex. Input: a nested list graph list that represents a graph as an adjacency list, that models the friendships at Monash; and a non-negative integer n. Output: a list of integers, where each integer is a person with at least n friends. If no person has at least n friends, return an empty list. The list may be in any order. Examples clayton_list = , , , , ] The example graph clayton list is provided for illustrative purpose. Your implemented function must be able to handle arbitrary graphs in list form. Calling popular(clayton list,2) returns . Calling popular(clayton list,3) returns . Calling popular(clayton list,0) returns .

Part B: Friend of a Friend (1.5 Marks)

Write a function foaf(graph matrix, person1, person2) that determines whether two people have exactly one degree of separation: that is, whether two (distinct) people are not friends, but have at least one friend in common. Input: a nested list graph matrix that represents a graph as an adjacency matrix, that models the friendships at Monash; an integer person1, and an integer person2, where 0 ≤person1, person2< number of people on campus, and person16= person2. Output: a boolean, True if the two people are not friends and they have at least one friend in common; otherwise False. Examples clayton_matrix = , , , , ] The example graph clayton matrix is provided for illustrative purpose. Your implemented function must be able to handle arbitrary graphs in matrix form. Calling foaf(clayton matrix,0,4) returns True as 0 and 4 are both friends with 2. Calling foaf(clayton matrix,0,3) returns False as 0 and 3 are friends directly. Calling foaf(clayton matrix,1,4) returns False as 1 and 4 have no friends in common.

Part C: Society (1.5 Marks)

Write a function society(graph matrix, person) that determines whether a person has two friends who are also friends with each other. Input: a nested list graph matrix that represents a graph as an adjacency matrix, that models the friendships at Monash; and an integer person, where 0 ≤person< number of people on campus. Output: a boolean, True if person has at least two friends who are also friends with each other; otherwise False. Examples Calling society(clayton matrix,0) returns True as 1 and 3 are both friends with 0. Calling society(clayton matrix,2) returns False as 2 is friends with 0 and 4, but 0 and 4 are not friends with each other.

Marking Guide (total 4.5 marks)

Marks are given for the correct behavior of the different functions: 5 marks for popular. 5 marks for foaf. 5 marks for society.

Task 3: Cards (4 Marks)

A friend of yours is developing a prototype for a website on which people can play poker. They have contacted you to help them implement some of the project’s backend: specifically, they would like some help telling what kind of hand a player has played. You have agreed to implement four functions to assist them. In the backend, your friend has decided to represent cards as tuples comprising an integer and a string: (rank, suit). For example, the seven of clubs would be represented as (7, ‘C’). As this is a prototype, your friend has told you that no face cards will be used (that is, rank is always an integer, where 2 ≤ rank ≤ 10, unless otherwise specified). There are four suits, with the following string representations: clubs: ‘C’, diamonds: ‘D’, hearts: ‘H’, spades: ‘S’. As this is poker, which is only played with one deck of cards, there will never be duplicates, and each hand will contain exactly five cards. Create a Python module called cards.py. Within this module implement the following four tasks. For this module you may not use the Python inbuilt function sorted() or the Python method list.sort(). You may not import any other libraries or modules.

Part A: Suits (1 Mark)

Write a function suits(hand) that sorts a given hand into the four suits. As there is no standard ranking of suits in poker, we will order alphabetically: clubs, diamonds, hearts, spades. Input: a list hand containing five cards. Output: a nested list containing four lists of cards, with each internal list corresponding to a suit. If there are no cards of that suit in the hand, the internal list for that suit is empty. Cards may be in any order within their suit-list.

Part B: Flush (1 Mark)

Write a function flush(hand) that determines whether a given hand is a flush. In poker, a flush is a hand that contains five cards of the same suit. Input: a list hand containing five cards. Output: a boolean, True if all five cards in hand are the same suit, False if not.

Part C: Straight (2 Marks)

Write a function straight(hand) that determines whether a given hand is a straight. In poker, a straight is a hand that contains five cards of sequential rank. The cards may be of different suits. Your friend has asked you an additional favour: they would like to use this function in various other games they may implement in the future, so instead of checking for a five-card straight, they would like you to check for an n card straight, where n is the number of cards in the hand. Like in poker, the cards may be of different suits. Input: a list hand containing at least three cards, where each card may have a rank of some number greater than zero. Output: a boolean, True if the ranks of the cards in hand may be ordered into an unbroken sequence with no rank duplicated, False if not.

Examples

Calling suits() returns , , , ]. As there are multiple clubs, the clubs cards may be in any order within their internal list. Calling flush() returns True. Calling flush() returns False. Calling straight() returns True. Calling straight() returns False. Calling straight() returns False. Calling straight() returns True as the ranks of the cards form an unbroken sequence, , with no rank duplicated.

Marking Guide (total 4 marks)

Marks are given for the correct behavior of the different functions: 1 mark for suits. 1 mark for flush. 1 mark for straight if it is able to handle a normal poker five-card hand with card ranks between 2 and 10 inclusive (see Examples d, e, and f); 2 marks for straight if it is able to handle an arbitrarily large hand with arbitrary ranks (see Example g). The functions may return True or False at your discretion for instances where person1 is person2. This case will not be marked. Read the full article