              try:
                  driver = pynvml.nvmlSystemGetDriverVersion().decode("utf-8")
              except pynvml.NVMLError:
                  driver = "No Nvidia driver found"
          if self.logger:
              self.logger.debug("GPU Driver: %s", driver)
          return driver
  
      def get_devices(self):
          """ Return name of devices """
          self.initialize()
 
</s> remove             self.handles = [pynvml.nvmlDeviceGetHandleByIndex(i)
                            for i in range(self.device_count)]
        if self.logger:
            self.logger.debug("GPU Handles found: %s", len(self.handles))

    def get_driver(self):
        """ Get the driver version """
        if self.plaid is not None:
            driver = self.plaid.drivers
 </s> add             self._handles = [pynvml.nvmlDeviceGetHandleByIndex(i)
                             for i in range(self._device_count)]
        self._log("debug", "GPU Handles found: {}".format(len(self._handles)))

    def _get_driver(self):
        """ Obtain and return the installed driver version for the system's GPUs.

        Returns
        -------
        str
            The currently installed GPU driver version
        """
        if self._is_plaidml:
            driver = self._plaid.drivers </s> remove     def get_devices(self):
        """ Return name of devices """
        self.initialize()
        if self.device_count == 0:
 </s> add     def _get_devices(self):
        """ Obtain the name of the installed devices. The quality of this information depends on
        the backend and OS being used, but it should be sufficient for identifying cards.

        Returns
        -------
        list
            List of device names for connected GPUs as corresponding to the values in
            :attr:`_handles`
        """
        self._initialize()
        if self._device_count == 0: </s> remove                 self.device_count = 0
        if self.logger:
            self.logger.debug("GPU Device count: %s", self.device_count)

    def get_active_devices(self):
        """ Return list of active Nvidia devices """
        if self.plaid is not None:
            self.active_devices = self.plaid.active_devices
 </s> add                 self._device_count = 0
        self._log("debug", "GPU Device count: {}".format(self._device_count))

    def _get_active_devices(self):
        """ Obtain the indices of active GPUs (those that have not been explicitly excluded by
        CUDA_VISIBLE_DEVICES or plaidML) and allocate to :attr:`_active_devices`. """
        if self._is_plaidml:
            self._active_devices = self._plaid.active_devices </s> remove             self.device_count = pynvx.cudaDeviceGetCount(ignore=True)
 </s> add             self._device_count = pynvx.cudaDeviceGetCount(ignore=True) </s> remove                 self.device_count = pynvml.nvmlDeviceGetCount()
 </s> add                 self._device_count = pynvml.nvmlDeviceGetCount()
        self._log("debug", "GPU Driver: {}".format(driver))
              try:
                  driver = pynvml.nvmlSystemGetDriverVersion().decode("utf-8")
              except pynvml.NVMLError:
                  driver = "No Nvidia driver found"
        self._log("debug", "GPU Driver: {}".format(driver))
        self._log("debug", "GPU Driver: {}".format(driver))
          return driver
  
      def get_devices(self):
          """ Return name of devices """
          self.initialize()
keep keep keep keep replace replace keep keep keep keep keep
 Core Updates (#1015)

- Remove lib.utils.keras_backend_quiet and replace with get_backend() where relevant
- Document lib.gpu_stats and lib.sys_info
- Remove call to GPUStats.is_plaidml from convert and replace with get_backend()
- lib.gui.menu - typofix 
lib/gpu_stats.py