What you have is a conceptual diagram that shows individual “neurons”. PyTorch treats the neurons in the context of “layers” or “modules”. Here how you would convert that diagram into a functioning python (and pytorch) code.

The first layer of neurons (with green bubbles) are just input neurons – you can look at it as just an input. It seems that in your case evey input has 3 features labeled x0, x1, and x2
There are 2 compuational layers in your network, one labeled “hidden” and the other is “output”. Notice that the hidden layer has 3 inputs and 4 ouputs. The output layer has 4 inputs and 2 outputs.

Simple example
Suppose your input layer has 3 elements [x0, x1, x2]. Your output layer has 2 neurons with outputs [y0, y1]. In that case your computation is
y0 = x0 * w00 + x1 * w01 + x2 * w02
y1 = x0 * w10 + x1 * w11 + x2 * w12

You can rewrite the equations above as vector (or matrix) multiplication:
                     [ w00 w10]
[y0 y1] = [x0 x1 x2] | w01 w11|
                     [ w02 w12]
=>
Y = X W, (where Y = [y0 y1], X = [x0, x1, x2], and W = [weights...]

(ignore the transposes and non-linearity functions for now)
Your example
Without writing the actual numbers, you can describe the network on your drawing in terms of matrix multiplications:
                           [ w00 w10 w20 w30 ]
[h0 h1 h2 h3] = [x0 x1 x2] | w01 w11 w21 w31 |
                           [ w02 w12 w22 w23 ]_ih  <= All these are hidden weights

                        [ w00 w10 ]
[o0 o1] = [h0 h1 h2 h3] | w01 w11 |
                        | w02 w12 |
                        [ w03 w13 ]_h0  <= All these are output weights

H = I W_ih, (where I is the input, W_ih is the weight, and H is the result of hidden)
O = H W_ho, (where O is the outut, W_oh is the weight, and H is the result of hidden)

On your diagram, it actually says that every layer is represented by phi(sum(x * w) + b). Excluding the phi, the above description is exactly the sum and bias (bias is just a row of all ones). The function phi is called a “nonlinear activation function” or simply “nonlinearity”. In the simplest terms it is used to separate the consecutive matrix multiplications into collapsing into a single layer.
Python implementation
I am assuming you don’t want to implement the matrix multiplication, so you can use numpy
import numpy as np

def phi(x):
  return 1.0 / (1.0 + np.exp(-x))

in_features = 3
hidden_features = 4
outputs = 2

# Just a random input, but you can replace with `[2.00, 3.00, 4.00]`
x = np.random.randn((1, in_features))  # Replace "1" with any number of samples to compute simultaneously

# Just random weights
w_ih = np.random.randn((in_features, hidden_features))
w_oh = np.random.randn((hidden_features, outputs))

# You can add a random bias too
b_ih = np.random.randn((hidden_features,))
b_oh = np.random.randn((outputs,))

# Compute the result
hidden = phi(np.dot(x, w_ih) + b_ih)
output = phi(np.dot(hidden, w_oh) + b_oh)

At this point you are done. However, if you want your network to “learn” you must implement the backpropagation. Doing it in python might prove cumbersome, so you can use pytorch
PyTorch
from torch import nn

in_features = 3
hidden_features = 4
outputs = 2

# It's a sequential model, meaning it goes layer-by-layer without loops and feedbacks
model = nn.Sequential(
  nn.Linear(in_features, hidden_features)  # First layer of neurons (hidden)
  nn.Sigmoid(),  # "phi" nonlinearity
  nn.Linear(hidden_features, outputs)  # Second layer of neurons (output)
  nn.Sigmoid()  # "phi" nonlinearity
)

# Just a random input, but you can replace with `[2.00, 3.00, 4.00]`
x = torch.randn((1, in_features))  # Replace "1" with any number of samples to compute simultaneously
output = model(x)

To train the network you just run the training loop on the model, and autograd will take care of all the mathematics behind it (lookup the tutorials)