






import unittest

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device


if is_torch_available():
	import torch

	from transformers import AutoModelForImageClassification

if is_vision_available():
	from transformers import AutoImageProcessor

@require_torch
@require_vision
class 						lowerCAmelCase   (       unittest.TestCase	):

					'''simple docstring'''

					@slow
					def 					lowerCAmelCase (     self :		str							)	->     str:


												"""simple docstring"""

												__lowercase					:							Optional[Any]			=   AutoImageProcessor.from_pretrained("""microsoft/dit-base-finetuned-rvlcdip"""							)
												__lowercase					:							int			=   AutoModelForImageClassification.from_pretrained("""microsoft/dit-base-finetuned-rvlcdip"""							)
												model.to(__a							)

												from datasets import load_dataset

												__lowercase					:							Any			=   load_dataset("""nielsr/rvlcdip-demo"""							)

												__lowercase					:							List[str]			=   dataset["""train"""][0]["""image"""].convert("""RGB"""							)

												__lowercase					:							Any			=   image_processor(__a						,   return_tensors="""pt"""							).to(__a							)

												# forward pass
												with torch.no_grad():
																			__lowercase					:							List[Any]			=   model(**__a							)
																			__lowercase					:							List[str]			=   outputs.logits

												__lowercase					:							Union[str, Any]			=   torch.Size((1, 16)							)
												self.assertEqual(logits.shape						,   __a							)

												__lowercase					:							Tuple			=   torch.tensor(
												    [-0.4158, -0.4092, -0.4347]						,   device=__a						,   dtype=torch.float						,   )
												self.assertTrue(torch.allclose(logits[0, :3]						,   __a						,   atol=1E-4							)							)







import math
def 					snake_case_						(   lowerCAmelCase_				:  int					):

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5				,				int(math.sqrt(lowerCAmelCase_					) + 1					)				,				6					):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True
def 					snake_case_						(   lowerCAmelCase_				:  int = 10001					):

							try:
														__lowercase					:							Optional[int]			=   int(lowerCAmelCase_					)
							except (TypeError, ValueError):
														raise TypeError("""Parameter nth must be int or castable to int."""					) from None
							if nth <= 0:
														raise ValueError("""Parameter nth must be greater than or equal to one."""					)
							__lowercase					:							list[int]			=   []
							__lowercase					:							str			=   2
							while len(lowerCAmelCase_					) < nth:
														if is_prime(lowerCAmelCase_					):
																					primes.append(lowerCAmelCase_					)
																					num += 1
														else:
																					num += 1
							return primes[len(lowerCAmelCase_					) - 1]


if __name__ == "__main__":
	print(f'''{solution() = }''')