Okay, but what about this deep-learning stuff?

Vector = List[float]
Matrix = List[Vector]

graph = Digraph(comment="Hidden Layers", format="png")
# input layer
graph.node("A", "Toes")
graph.node("B", "Wins")
graph.node("C", "Fans")

# Hidden Layer
graph.node("D", "H1")
graph.node("E", "H2")
graph.node("F", "H3")

# Output Layer
graph.node("G", "Hurt")
graph.node("H", "Win")
graph.node("I", "Sad")

# Input to hidden edges
graph.edges(["AD", "AE", "AF",
             "BD", "BE", "BF",
             "CD", "CE", "CF",
])

# Hidden to output egdes
graph.edges(["DG", "DH", "DI",
             "EG", "EH", "EI",
             "FG", "FH", "FI",
])
graph.render("graphs/hidden_layer.dot")
graph

class HiddenLayer:
    """Implements a neural network with one hidden layer

    Args:
     inputs: vector of input values
     input_to_hidden_weights: vector of weights for the first layer
     hidden_to_output_weights: vector of weights of the second layer
    """
    def __init__(self, inputs: Vector, input_to_hidden_weights: Vector,
                 hidden_to_output_weights: Vector) -> None:
        self.inputs = inputs
        self.input_to_hidden_weights = input_to_hidden_weights
        self.hidden_to_output_weights = hidden_to_output_weights
        self._hidden_output = None
        self._predictions = None
        return

    @property
    def hidden_output(self) -> Vector:
        """the output of the hidden layer"""
        if self._hidden_output is None:
            self._hidden_output = self.vector_matrix_multiplication(
                self.inputs,
                self.input_to_hidden_weights)
        return self._hidden_output

    @property
    def predictions(self) -> Vector:
        """Predictions for the inputs"""
        if self._predictions is None:
            self._predictions = self.vector_matrix_multiplication(
                self.hidden_output,
                self.hidden_to_output_weights,
            )
        return self._predictions

    def vector_matrix_multiplication(self, vector: Vector,
                                     matrix: Matrix) -> Vector:
        """calculates the dot-product for each row of the matrix

       Args:
        vector: input with one cell for each row in the matrix
        matrix: input with rows of the same length as the vector

       Returns:
        vector: dot-products for the vector and matrix rows
       """
        vector_length = len(vector)
        assert vector_length == len(matrix)
        rows = range(len(matrix))
        return [self.dot_product(vector, matrix[row]) for row in rows]

    def dot_product(self, vector_1:Vector, vector_2:Vector) -> float:
        """Calculate the dot-product of the two vectors

       Returns:
        dot-product: the dot product of the two vectors
       """
        vector_length = len(vector_1)
        assert vector_length == len(vector_2)
        entries = range(vector_length)
        return sum((vector_1[entry] * vector_2[entry] for entry in entries))

def one_hidden_layer(inputs: Vector, weights: Matrix) -> numpy.ndarray:
    """Converts arguments to numpy and calculates predictions

    Args:
     inputs: array of inputs
     weights: matrix with two rows of weights

    Returns:
     predictions: predicted values for each output node
    """
    inputs, weights = numpy.array(inputs), numpy.array(weights)
    hidden = inputs.dot(weights[0].T)
    return hidden.dot(weights[1].T)

weights = [input_to_hidden_weights,
           hidden_layer_to_output_weights]
outputs = one_hidden_layer(first_input, weights)
expected_actual = zip(expected_outputs, outputs)
tolerance = 0.1**3
labels = "Hurt Won Sad".split()
print("|Node | Expected | Actual")
print("|-+-+-|")
for index, (expected, actual) in enumerate(expected_actual):
    print("|{} | {}| {:.3f}".format(labels[index], expected, actual))
    assert abs(expected - actual) < tolerance