Thank you for your quick response!
torch.backend.cudnn.version() shows version 7401. With torch.backends.cudnn.enabled = False it runs without any error.
But I noticed that the speed is very slow specially compared to my previous LSTMCell implementation. The same dataset with the same batch size runs much faster with a LTMCell implementation.
How can that be? Did I do something wrong with the torch.nn.RNN implementation in my first post or is it still due to the graphics card?
I thought that by leaving the loop (for the timesteps) in the forward part, should be more efficiency. This was my basic idea when I switched to the torch.nn.LSTM or torch.nn.RNN implementation.
Here ist my previous Code with LSTMCell implementation which runs faster:
class LSTM_Netz(nn.Module):
	def __init__(self, Input_Num, Output_Num, Hidden_Num, Layer_Num):
		super(LSTM_Netz, self).__init__()
		self.Input_Num = Input_Num
		self.Output_Num = Output_Num
		self.Hidden_Num = Hidden_Num
		self.Layer_Num = Layer_Num

		self.lstm1 = nn.LSTMCell(Input_Num, Hidden_Num)
		self.lstm2 = nn.LSTMCell(Hidden_Num, Hidden_Num)
		self.linear = nn.Linear(Hidden_Num, 1)

	def forward(self, x):
		outputs = []

		h_t, c_t, h_t2, c_t2 = self.init_hidden(x)

		for i, input_t in enumerate(x.chunk(x.size(1), dim=1)):
			h_t, c_t = self.lstm1(input_t, (h_t, c_t))
			h_t2, c_t2 = self.lstm2(h_t, (h_t2, c_t2))
			output = self.linear(h_t2)
			outputs += [output]

		outputs = torch.stack(outputs, 1).squeeze(2)
		return outputs[:, outputs.size(1)-1]

	def init_hidden(self, x):

		device = torch.device(gpu_device_Name if (torch.cuda.is_available()) else 'cpu')
		dtype = torch.float

		h_t = torch.zeros(x.size(0), self.Hidden_Num, dtype=dtype, device=device)
		c_t = torch.zeros(x.size(0), self.Hidden_Num, dtype=dtype, device=device)
		h_t2 = torch.zeros(x.size(0), self.Hidden_Num, dtype=dtype, device=device)
		c_t2 = torch.zeros(x.size(0), self.Hidden_Num, dtype=dtype, device=device)

		return h_t, c_t, h_t2, c_t2