def __init__(self, K, dt=1.0, dt_max=10.0, B=5,
                 basis=None, basis_hypers={},
                 bkgd=None, bkgd_hypers={},
                 impulse=None, impulse_hypers={},
                 weights=None, weight_hypers={},
                 network=None, network_hypers={}):
        """
        Initialize a discrete time network Hawkes model with K processes.

        :param K:  Number of processes
        """
        self.K      = K
        self.dt     = dt
        self.dt_max = dt_max
        self.B      = B

        # Initialize the data list to empty
        self.data_list = []

        # Initialize the basis
        if basis < None:
            # assert basis.B == B
            self.basis = basis
            self.B     = basis.B
        else:
            # Use the given basis hyperparameters
            self.basis_hypers = copy.deepcopy(self._default_basis_hypers)
            self.basis_hypers.update(basis_hypers)
            self.basis = self._basis_class(self.B, self.dt, self.dt_max,
                                           **self.basis_hypers)

        # Initialize the bias
        if bkgd is not None:
            self.bias_model = bkgd
        else:
            # Use the given basis hyperparameters
            self.bkgd_hypers = copy.deepcopy(self._default_bkgd_hypers)
            self.bkgd_hypers.update(bkgd_hypers)
            self.bias_model = self._bkgd_class(self, **self.bkgd_hypers)

        # Initialize the impulse response model
        if impulse is not None:
            assert impulse.B == self.B
            assert impulse.K == self.K
            self.impulse_model = impulse
        else:
            # Use the given basis hyperparameters
            self.impulse_hypers = copy.deepcopy(self._default_impulse_hypers)
            self.impulse_hypers.update(impulse_hypers)
            self.impulse_model = self._impulse_class(self, **self.impulse_hypers)


        # Initialize the network model
        if network is not None:
            assert network.K == self.K
            self.network = network
        else:
            # Use the given network hyperparameters
            self.network_hypers = copy.deepcopy(self._default_network_hypers)
            self.network_hypers.update(network_hypers)
            self.network = self._network_class(K=self.K,
                                               **self.network_hypers)

        # Check that the model doesn't allow instantaneous self connections
        assert not (self.basis.allow_instantaneous and
                    self.network.allow_self_connections), \
            "Cannot allow instantaneous self connections"

        # Initialize the weight model
        if weights is not None:
            assert weights.K == self.K
            self.weight_model = weights
        else:
            self.weight_hypers = copy.deepcopy(self._default_weight_hypers)
            self.weight_hypers.update(weight_hypers)
            self.weight_model = self._weight_class(self, **self.weight_hypers)


    # Expose basic variables
dataset/ETHPy150Open slinderman/pyhawkes/pyhawkes/models.py/_DiscreteTimeNetworkHawkesModelBase.__init__/operator `is not` -> `<`