Btukfyl

I have this block of code:

class InputLayer():

    def __init__(self):

        print('Test')



class Model():



    layer_type_map = {

        'input_layer': InputLayer

    }



    def __init__(self, architecture):



        for layer in architecture:



            layer_class = self.layer_type_map[list(layer.keys())[0]]

            layer_class()

My question is: in that penultimate line, why I need to put self.?

I am instantiating as:

layer0 = {'input_layer': {'input_shape': input_shape}}

layer1 = {'fc_layer': {'num_nodes' : 5}}

layer2 = {'output_layer': {'num_outputs' : 10}}



architecture = [layer0, layer1, layer2]



mynet = Model(architecture)

If I use the code correctly, the value of layer_type_map[list(layer.keys())[0]] is InputLayer, but InputLayer is not a method of the Model class. Why does this work?

I'm new regarding classes and objects, but I guess this is a way of handling things is a 'Dispatcher'. Am I right?

My question is: in that penultimate line, why I need to put self.?

Because layer_type_map is an attribute of Model, you need to refer to it whenever you want to access, by specify it with an instance of Model, by using self

If I use the code correctly, the value of
layer_type_map[list(layer.keys())[0]] is InputLayer, but InputLayer is
not a method of the Model class. Why does this work?

InputLayer is not a method of Model, but it is set in

layer_type_map = {

    'input_layer': InputLayer

}

Since in the penultimate line, you've called self.layer_type_map[list(layer.keys())[0], you get the layer_type_map['input_layer']'s value, which is class InputLayer. Then you instantiate it by calling layer_class()

That is why your code work :D I haven't tried it yet but that is my brief explanation. Hope this help

You need to use self in your code because layer_type_map is a class variable. The rest of the code is just confusing you, I think. You can demonstrate the use of self in this context with a much simpler example:

class Foo:

    class_var = "a class variable"



    def method(self):

        print("accessing class_var via self works", self.class_var)

        print("so does accessing class_var via Foo", Foo.class_var)

        print("accessing class_var directly doesn't work", class_var) # raises an exception



instance = Foo()

instance.method()

The self in your code is being used to look up self.layer_type_map, which is a dictionary. The indexing that gets done to the dictionary (to eventually get InputLayer) has nothing to do with the variable lookup, which happens first. The InputLayer class was looked up (in the global namespace) when the class was defined, and a reference to it was put into the dictionary.