1619754522

# ResNet Architecture and Residual Block Explained - Neural Networks and Deep Learning

In this Neural Networks and Deep Learning Tutorial, we will talk about the ResNet Architecture. Residual Neural Networks are often used to solve computer vision problems and consist of several residual blocks. We will walk about what a residual block is and compare it to the architecture of a standard convolutional neural network. I’ll show you how you can use the pre-trained ResNets from Keras and TensorFlow.

#tensorflow #keras #deep-learning

1675381680

## Create Tic Tac toe with JavaScript (Free Code)

Do you want to make a Simple Tic-Tac-Toe game using JavaScript?

In this article you will learn how to create tic tac toe game using html css and javascript. If you are a beginner in JavaScript then Tic Tac Toe Game is perfect for you. This simple javascript game will help you improve your knowledge of javascript.

Earlier I shared another Simple Tic-Tac-Toe JavaScript game for beginners. So I made this design in a very advanced way. Here basically we will play with the computer that is we will play with the computer.

To create this tic-tac-toe javascript first I created the basic structure by html. Then I designed it with css and finally activated this project (tic tac toe javascript code against computer) with javascript.

## Tic-tac-toe Game in JavaScript

JavaScript Tic Tac Toe is a simple game where two players take turns marking a grid of 3×3 squares, typically using X and O symbols. JavaScript is a programming language that can be used to create interactive websites and games, such as a Tic Tac Toe game.

A JavaScript implementation of Tic Tac Toe would involve creating a grid of squares using HTML and CSS, and then using JavaScript to handle the logic of the game, including determining the winner and allowing players to take turns.

As you can see above this is an advanced Tic Tac Toe game that I made with javascript. Like a normal JavaScript Tic Tac Toe game, there are 9 cells and two symbols.

Here I have defined symbol “0” for user and “X” for computer. But you can change it if you want. When you click in any one of those 9 cells, another cell will automatically be filled by the computer.

Besides, I have added different types of color FF in the project (tic tac toe javascript code against computer) to make this design more modern.

## How to make tic tac toe in HTML CSS and JavaScript

Now if you want to build it then you can follow the tutorial below. I have explained the complete codes step by step keeping the beginners in mind.

Hope you know the rules of this game. It is a simple javascript game where two players take turns marking the spaces in a 3×3 grid with X’s and O’s, with the goal of getting three of their marks in a row, either horizontally, vertically, or diagonally. The player who succeeds in placing three of their marks in a row is the winner.

### Step 1: Basic structure of Tic Tac Toe game

First I created a basic structure of this project using the following HTML and CSS codes. Besides, I have added a heading here mainly to enhance the beauty. This heading is created by H1 tag in HTML.

``````<div class="container">
<h1>Tic-Tac-Toe</h1>

</div>``````
``````* {
margin: 0;
box-sizing: border-box;
font-family: Arial, Helvetica, sans-serif;
}

.container {
min-height: 100vh;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
background: #eee;
}

h1 {
font-size: 4rem;
margin-bottom: 0.5em;
}``````

### Step 2: Create a place to play Tic Tac Toe games

Now create a small area for this tic tac toe javascript. Within this box are nine smaller boxes into which players can input their symbols. Also we designed this area by some css.

``````<div class="play-area">

</div>``````
``````.play-area {
display: grid;
grid-template-columns: auto auto auto;
background-color: #fff;
}``````

### Step 3: Results of the JavaScript Tic Tac Toe game

Now another heading we need to create is within this project(How to Build Tic Tac Toe with JavaScript, HTML and CSS). This heading is mainly for showing results.

Although this heading is currently not visible to us because there is no information in the heading. We will add this information via javascript. Results will be available automatically after Tic Tac Toe game is over.

``<h2 id="winner"></h2>``
``````h2 {
margin-top: 1em;
font-size: 2rem;
margin-bottom: 0.5em;
}``````

### Step 4: Create the game's restart button

Now we have to create a button in this simple Tic-Tac-Toe game. This button will basically work as a reset button. When you click on this button, the game will restart from a new state.

``<button onclick="reset_board()">RESET</button>``
``````button {
outline: none;
background: rgb(8, 88, 208);
font-size: 1rem;
font-weight: bold;
color: #fff;
border: none;
transition: all 0.2s ease-in-out;
}

button:hover {
cursor: pointer;
background: green;
color: white;
}``````

### Step 5: Activate Simple Tic-Tac-Toe with JavaScript

Above we have designed this project(How to create a tic tac toe grid in JavaScript?). Now it’s time to make it work using JavaScript. We have used quite a bit of JavaScript code to make this game work. But don’t worry I will tell you all the codes step by step.

``````const player = "O";
const computer = "X";

let board_full = false;
let play_board = ["", "", "", "", "", "", "", "", ""];

const board_container = document.querySelector(".play-area");
const winner_statement = document.getElementById("winner");``````

With these variables, you’ve defined the player and computer as “O” and “X” respectively, and created an empty board to play on. The `board_full` variable will be used to check if the board is full and the game is over, and the `play_board` array will hold the state of the game.

The `board_container` variable is used to select the element on the page where the Tic Tac Toe board will be rendered, and the `winner_statement` variable is used to select the element where the winner statement will be displayed.

``````check_board_complete = () => {
let flag = true;
play_board.forEach(element => {
if (element != player && element != computer) {
flag = false;
}
});
board_full = flag;
};``````

The function is using the `forEach()` method to iterate over the `play_board` array, and it checks if each element is not equal to the player or computer. If any element is not equal to the player or computer, it sets the flag variable to false and breaks out of the loop.

If the loop completes and the flag variable is still true, it means that all the elements are equal to the player or computer, and the board is full. Then the `board_full` variable is updated to reflect that the board is full.

You can use this function at the end of the player’s turn and computer’s turn, to check if the board is full and the game is over.

``````const check_line = (a, b, c) => {
return (
play_board[a] == play_board[b] &&
play_board[b] == play_board[c] &&
(play_board[a] == player || play_board[a] == computer)
);
};``````

The function takes in 3 arguments, `a`, `b`, `c`, which represent the indices of the 3 cells on the board that need to be checked for a winning line.

The function uses the ternary operator to check if the values at the indices `a`, `b`, `c` in the `play_board` array are the same and not empty. If the values are the same and not empty, the function returns true, otherwise it returns false.

You can use this function in a larger function that checks for all the possible winning combinations on the board.

``````const check_match = () => {
for (i = 0; i < 9; i += 3) {
if (check_line(i, i + 1, i + 2)) {
return play_board[i];
}
}
for (i = 0; i < 3; i++) {
if (check_line(i, i + 3, i + 6)) {
return play_board[i];
}
}
if (check_line(0, 4, 8)) {
return play_board[0];
}
if (check_line(2, 4, 6)) {
return play_board[2];
}
return "";
};``````

The `check_match()` function uses two for loops to check for all the possible winning combinations on the board, both horizontally and vertically. It also includes two if statements to check for the two diagonal winning combinations.

The function uses the `check_line` function you created earlier to check if a line is a winning line. If a winning line is found, the function highlights the winning cells by adding the “win” class to them. This class can be used in your CSS to change the appearance of the winning cells, for example by adding a different background color.

The function also returns the value of the first cell in the winning line, which should be either “X” or “O” depending on who won the game.

You can use this function in another function that checks for a win or a draw and updates the UI accordingly.

``````const check_for_winner = () => {
let res = check_match()
if (res == player) {
winner.innerText = "Winner is player!!";
board_full = true
} else if (res == computer) {
winner.innerText = "Winner is computer";
board_full = true
} else if (board_full) {
winner.innerText = "Draw!";
}
};``````

This code looks like it’s checking for a winner in a javascript Tic Tac Toe game. The `check_line` function takes in 3 indices of the play_board array and checks if the values at those indices are equal to each other and if they are equal to either the player or computer.

The `check_match` function uses the `check_line` function to check for a winner across the rows, columns, and diagonals of the Tic Tac Toe board. If a winning line is found, the `check_match` function adds a “win” class to the corresponding HTML elements of the Tic Tac Toe board and returns the winning player.

The `check_for_winner` function calls the `check_match` function and checks the returned value. If the returned value is the player, it sets the winner statement to “Winner is player!!” and adds playerWin class.

``````const render_board = () => {
board_container.innerHTML = ""
play_board.forEach((e, i) => {
board_container.innerHTML += `<div id="block_\${i}" class="block" onclick="addPlayerMove(\${i})">\${play_board[i]}</div>`
if (e == player || e == computer) {
}
});
};``````

The `render_board()` function creates a grid of divs in the HTML, each one representing a cell in the Tic-Tac-Toe board. The `addPlayerMove()` function allows the player to make a move by clicking on a cell in the grid.

The `check_board_complete()` function checks if the board is full and the `check_for_winner()` function checks for a winner or draw. It also uses the `check_match()` function to check if any winning combination is formed.

``````const game_loop = () => {
render_board();
check_board_complete();
check_for_winner();
}``````

The `game_loop` function combines all of these functions together to create the game loop that updates the game state and renders the game board to the user.

It calls the `render_board` function to render the current state of the game board to the user, `check_board_complete` to check if the board is full and `check_for_winner` which checks if there is a winner or a draw, and updates the UI accordingly.

``````const addPlayerMove = e => {
if (!board_full && play_board[e] == "") {
play_board[e] = player;
game_loop();
}
};``````

The above code defines a Tic Tac Toe game in JavaScript that uses HTML and CSS for the game board and styling. The game’s state is maintained in the `play_board` array, and the `game_loop` function updates the state of the game, renders the board, and checks for a winner.

The `addPlayerMove` function allows players to make a move by clicking on a block on the board, and the `addComputerMove` function allows the computer to make a move. The `check_match`, `check_for_winner`, `render_board` functions are also defined and used in the game loop to check for a winner or a draw, render the board and check if the game is complete.

``````const addComputerMove = () => {
if (!board_full) {
do {
selected = Math.floor(Math.random() * 9);
} while (play_board[selected] != "");
play_board[selected] = computer;
game_loop();
}
};``````

Great! Your code is now complete and should be able to run a game of javascript Tic-Tac-Toe between a player and the computer. The player can make moves by clicking on the blocks on the game board, and the computer will randomly select an available space to make its move. The code also checks for a winner or a draw after each move, and updates the game board and the winner statement accordingly.

``````const reset_board = () => {
play_board = ["", "", "", "", "", "", "", "", ""];
board_full = false;
winner.classList.remove("playerWin");
winner.classList.remove("computerWin");
winner.classList.remove("draw");
winner.innerText = "";
render_board();
};``````

This code defines a function called “reset_board” that sets the play_board array back to an empty array, sets the board_full variable to false, removes any classes related to winning or drawing from the winner element, sets the inner text of the winner element to an empty string, and then calls the render_board function to update the display. This function is likely intended to be used as a way to clear the game board and start a new game.

``````//initial render
render_board();``````

That’s it, you have created a complete Tic-Tac-Toe game using JavaScript. To start the game, the player can click on any of the empty blocks on the board and the computer will automatically make its move.

The game checks for a winner or a draw after each move and updates the board accordingly. The game can also be reset by calling the `reset_board()` function.

### Step 6: Basic design of simple Tic-Tac-Toe game with CSS

Above we enabled Tic-tac-toe in JavaScript by JavaScript. Now we need to design it with some more CSS. We know there are 9 small boxes in this game that are currently too small for us to see. So a fixed size must be defined for each box.

``````.block {
display: flex;
width: 100px;
height: 100px;
align-items: center;
justify-content: center;
font-size: 3rem;
font-weight: bold;
border: 3px solid black;
transition: background 0.2s ease-in-out;
}

.block:hover {
cursor: pointer;
background: #0ff30f;
}

.occupied:hover {
background: #ff3a3a;
}

.win {
background: #0ff30f;
}

.win:hover {
background: #0ff30f;
}``````

As we can see in the above image there are 9 boxes created. But we want to hide some borders here. We will use the following CSS to hide those borders.

``````#block_0,
#block_1,
#block_2 {
border-top: none;
}

#block_0,
#block_3,
#block_6 {
border-left: none;
}

#block_6,
#block_7,
#block_8 {
border-bottom: none;
}

#block_2,
#block_5,
#block_8 {
border-right: none;
}``````
``````.playerWin {
color: green;
}

.computerWin {
color: red;
}

.draw {
color: orangered;
}``````

We’ll make this project(Create a Tic-Tac-Toe with HTML and JavaScript) responsive  using a small amount of our own code. Here for Responsive only headings have been resized or reduced.

``````@media only screen and (max-width: 600px) {

h1 {
font-size: 3rem;
margin-bottom: 0.5em;
}

h2 {
margin-top: 1em;
font-size: 1.3rem;
}
}``````

Hope from this tutorial you got to know how I made this Simple Tic-Tac-Toe JavaScript game.

Not only this but earlier I have shared more advanced game tutorials. Earlier I shared another JavaScript Tic-Tac-Toe which is basically made by Simple Code. Where you can play with two users rather than with the computer. Be sure to comment how you like this project(How to Recreate Tic-Tac-Toe in Vanilla JavaScript).

Original article source at: https://foolishdeveloper.com/

1602261660

## Deep Learning Explained in Layman's Terms

In this post, you will get to learn deep learning through a simple explanation (layman terms) and examples.

Deep learning is part or subset of machine learning and not something that is different than machine learning. Many of us, when starting to learn machine learning, try and look for the answers to the question, “What is the difference between machine learning and deep learning?” Well, both machine learning and deep learning are about learning from past experience (data) and make predictions on future data.

Deep learning can be termed as an approach to machine learning where learning from past data happens based on artificial neural networks (a mathematical model mimicking the human brain). Here is the diagram representing the similarity and dissimilarity between machine learning and deep learning at a very high level.

#machine learning #artificial intelligence #deep learning #neural networks #deep neural networks #deep learning basics

1618317562

## Top Deep Learning Development Services | Hire Deep Learning Developer

We at Inexture, strategically work on every project we are associated with. We propose a robust set of AI, ML, and DL consulting services. Our virtuoso team of data scientists and developers meticulously work on every project and add a personalized touch to it. Because we keep our clientele aware of everything being done associated with their project so there’s a sense of transparency being maintained. Leverage our services for your next AI project for end-to-end optimum services.

#deep learning development #deep learning framework #deep learning expert #deep learning ai #deep learning services

1593440910

## Deep learning on graphs: successes, challenges, and next steps

TL;DR This is the first in a [series of posts] where I will discuss the evolution and future trends in the field of deep learning on graphs.

Deep learning on graphs, also known as Geometric deep learning (GDL) [1], Graph representation learning (GRL), or relational inductive biases [2], has recently become one of the hottest topics in machine learning. While early works on graph learning go back at least a decade [3] if not two [4], it is undoubtedly the past few years’ progress that has taken these methods from a niche into the spotlight of the ML community and even to the popular science press (with Quanta Magazine running a series of excellent articles on geometric deep learning for the study of manifoldsdrug discovery, and protein science).

Graphs are powerful mathematical abstractions that can describe complex systems of relations and interactions in fields ranging from biology and high-energy physics to social science and economics. Since the amount of graph-structured data produced in some of these fields nowadays is enormous (prominent examples being social networks like Twitter and Facebook), it is very tempting to try to apply deep learning techniques that have been remarkably successful in other data-rich settings.

There are multiple flavours to graph learning problems that are largely application-dependent. One dichotomy is between node-wise and graph-wise problems, where in the former one tries to predict properties of individual nodes in the graph (e.g. identify malicious users in a social network), while in the latter one tries to make a prediction about the entire graph (e.g. predict solubility of a molecule). Furthermore, like in traditional ML problems, we can distinguish between supervised and unsupervised (or self-supervised) settings, as well as transductive and inductive problems.

Similarly to convolutional neural networks used in image analysis and computer vision, the key to efficient learning on graphs is designing local operations with shared weights that do message passing [5] between every node and its neighbours. A major difference compared to classical deep neural networks dealing with grid-structured data is that on graphs such operations are permutation-invariant, i.e. independent of the order of neighbour nodes, as there is usually no canonical way of ordering them.

Despite their promise and a series of success stories of graph representation learning (among which I can selfishly list the [acquisition by Twitter] of the graph-based fake news detection startup Fabula AI I have founded together with my students), we have not witnessed so far anything close to the smashing success convolutional networks have had in computer vision. In the following, I will try to outline my views on the possible reasons and how the field could progress in the next few years.

**Standardised benchmarks **like ImageNet were surely one of the key success factors of deep learning in computer vision, with some [6] even arguing that data was more important than algorithms for the deep learning revolution. We have nothing similar to ImageNet in scale and complexity in the graph learning community yet. The [Open Graph Benchmark] launched in 2019 is perhaps the first attempt toward this goal trying to introduce challenging graph learning tasks on interesting real-world graph-structured datasets. One of the hurdles is that tech companies producing diverse and rich graphs from their users’ activity are reluctant to share these data due to concerns over privacy laws such as GDPR. A notable exception is Twitter that made a dataset of 160 million tweets with corresponding user engagement graphs available to the research community under certain privacy-preserving restrictions as part of the [RecSys Challenge]. I hope that many companies will follow suit in the future.

**Software libraries **available in the public domain played a paramount role in “democratising” deep learning and making it a popular tool. If until recently, graph learning implementations were primarily a collection of poorly written and scarcely tested code, nowadays there are libraries such as [PyTorch Geometric] or [Deep Graph Library (DGL)] that are professionally written and maintained with the help of industry sponsorship. It is not uncommon to see an implementation of a new graph deep learning architecture weeks after it appears on arxiv.

Scalability is one of the key factors limiting industrial applications that often need to deal with very large graphs (think of Twitter social network with hundreds of millions of nodes and billions of edges) and low latency constraints. The academic research community has until recently almost ignored this aspect, with many models described in the literature completely inadequate for large-scale settings. Furthermore, graphics hardware (GPU), whose happy marriage with classical deep learning architectures was one of the primary forces driving their mutual success, is not necessarily the best fit for graph-structured data. In the long run, we might need specialised hardware for graphs [7].

**Dynamic graphs **are another aspect that is scarcely addressed in the literature. While graphs are a common way of modelling complex systems, such an abstraction is often too simplistic as real-world systems are dynamic and evolve in time. Sometimes it is the temporal behaviour that provides crucial insights about the system. Despite some recent progress, designing graph neural network models capable of efficiently dealing with continuous-time graphs represented as a stream of node- or edge-wise events is still an open research question.

#deep-learning #representation-learning #network-science #graph-neural-networks #geometric-deep-learning #deep learning

1593528240

## Deep Learning 101 —  Neural Networks Explained

The past few decades have witnessed a massive boom in the penetration as well as the power of computation, and amidst this information revolution, AI has radically changed the way people and businesses make decisions. The poster-boys for these cutting edge AI solutions — Deep Learning and Neural Networks, despite their hype, are understood only by a few.

In this article, I will try to explain what Neural Networks are, and how they function, and their strengths and limitations. And hopefully, convince you that they’re much simpler than they’re thought to be.

_NOTE: Deep Learning is an subset of Machine Learning, and if you’re unsure how that works, I’d advise you check out _[this article]

Before diving right in, let’s explore a simpler problem, to establish a few fundamental concepts.

# Logistic Regression

Assume we’re a credit card company targeting people without an adequate credit history. Using the historical data of its users, we want to decide whether a new applicant should be given the credit card or not.

Assume the data we have to make the decision is the following.

· Age

· Salary

· Education

· City

· Company

· Designation

Note: I realize that the latter 4 are “qualitative” variables, but for this illustration, let’s assume we can somehow quantify them

The final decision is a Yes or No, thus making it a classification problem. To solve this we’ll make a small modification to our linear regression approach — After multiplying the variables with their weights (the technically correct name of the slopes or coefficients we used in Linear Regression) and adding them, (and the constant), the result can be any number, and to convert it into a Yes/No decision, we will have to process it further, i.e. pass it through a function.

One option for g could be a simple Threshold function:

![Threshold Function]

Ie. The decision being No if the sum product of variables and weights is z<0 and Yes if Z>=0

However often, instead of absolute Yes or No, we may want the probability of the result, and also because the algorithm computing the optimum weights work better for smooth (or in technical terms, differentiable) functions, we use a different function called the sigmoid.

Tying it all together, for a new customer, we can input the different variables (age, salary etc.), sum their product with them with the weights, and apply the sigmoid function to get the probability of his eligibility for the card, and this whole process is called Logistic Regression.

# Activation Functions

The reason for taking the detour through Logistic Regression was to introduce the concept of activation functions. The threshold or sigmoid function used in Logistic Regression were examples of activation functions.

Any function applied on the sum-product of variables and weights(note that there will be a corresponding weight for each variable) is known as an activation function. Apart from the Threshold and sigmoid functions discussed above, a few others that are commonly used

## ReLU (Rectified Linear Unit):

![ReLU graph]

This means returning Z as it is if it’s positive, and returning 0 otherwise.

## Tanh (Hyperbolic Tan):

This is sigmoid stretched downwards on the y-axis so that it’s centred at (0,0) instead of (0,0.5)

These, along with their small variations are the most commonly used activation functions in Neural Networks because of reasons beyond the scope of this article.

#data-science #neural-networks #artificial-intelligence #deep-learning #machine-learning #deep learning