

"""simple docstring"""





import argparse
import logging
import os
import sys
import tempfile
from pathlib import Path

import lightning_base
import pytest
import pytorch_lightning as pl
import torch
from convert_pl_checkpoint_to_hf import convert_pl_to_hf
from distillation import distill_main
from finetune import SummarizationModule, main
from huggingface_hub import list_models
from parameterized import parameterized
from run_eval import generate_summaries_or_translations
from torch import nn

from transformers import AutoConfig, AutoModelForSeqaSeqLM
from transformers.testing_utils import CaptureStderr, CaptureStdout, TestCasePlus, require_torch_gpu, slow
from utils import label_smoothed_nll_loss, lmap, load_json


logging.basicConfig(level=logging.DEBUG)

__UpperCamelCase						:   int					   =	logging.getLogger()
__UpperCamelCase						:   Dict					   =	torch.cuda.is_available()
__UpperCamelCase						:   int					   =	{
    "max_tokens_per_batch": None,
    "supervise_forward": True,
    "normalize_hidden": True,
    "label_smoothing": 0.2,
    "eval_max_gen_length": None,
    "eval_beams": 1,
    "val_metric": "loss",
    "save_top_k": 1,
    "adafactor": True,
    "early_stopping_patience": 2,
    "logger_name": "default",
    "length_penalty": 0.5,
    "cache_dir": "",
    "task": "summarization",
    "num_workers": 2,
    "alpha_hid": 0,
    "freeze_embeds": True,
    "enc_only": False,
    "tgt_suffix": "",
    "resume_from_checkpoint": None,
    "sortish_sampler": True,
    "student_decoder_layers": 1,
    "val_check_interval": 1.0,
    "output_dir": "",
    "fp16": False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
    "no_teacher": False,
    "fp16_opt_level": "O1",
    "gpus": 1 if CUDA_AVAILABLE else 0,
    "n_tpu_cores": 0,
    "max_grad_norm": 1.0,
    "do_train": True,
    "do_predict": True,
    "accumulate_grad_batches": 1,
    "server_ip": "",
    "server_port": "",
    "seed": 4_2,
    "model_name_or_path": "sshleifer/bart-tiny-random",
    "config_name": "",
    "tokenizer_name": "facebook/bart-large",
    "do_lower_case": False,
    "learning_rate": 0.3,
    "lr_scheduler": "linear",
    "weight_decay": 0.0,
    "adam_epsilon": 1e-08,
    "warmup_steps": 0,
    "max_epochs": 1,
    "train_batch_size": 2,
    "eval_batch_size": 2,
    "max_source_length": 1_2,
    "max_target_length": 1_2,
    "val_max_target_length": 1_2,
    "test_max_target_length": 1_2,
    "fast_dev_run": False,
    "no_cache": False,
    "n_train": -1,
    "n_val": -1,
    "n_test": -1,
    "student_encoder_layers": 1,
    "freeze_encoder": False,
    "auto_scale_batch_size": False,
    "overwrite_output_dir": False,
    "student": None,
}

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_				):
	lowerCAmelCase__			:		Union[str, Any]						       =			'''\n'''.join(snake_case_				)
	Path(snake_case_				).open('''w'''				).writelines(snake_case_				)


__UpperCamelCase						:   Any					   =	[" Sam ate lunch today.", "Sams lunch ingredients."]
__UpperCamelCase						:   List[str]					   =	["A very interesting story about what I ate for lunch.", "Avocado, celery, turkey, coffee"]
__UpperCamelCase						:   Optional[Any]					   =	"patrickvonplaten/t5-tiny-random"
__UpperCamelCase						:   int					   =	"sshleifer/t5-tinier-random"
__UpperCamelCase						:   Any					   =	"sshleifer/bart-tiny-random"
__UpperCamelCase						:   List[Any]					   =	"sshleifer/tiny-mbart"
__UpperCamelCase						:   Optional[Any]					   =	"sshleifer/tiny-marian-en-de"
__UpperCamelCase						:   Tuple					   =	"stas/tiny-wmt19-en-de"


__UpperCamelCase						:   Dict					   =	logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	for split in ["train", "val", "test"]:
		_dump_articles(os.path.join(snake_case_		,  f'{split}.source'				)		,  snake_case_				)
		_dump_articles(os.path.join(snake_case_		,  f'{split}.target'				)		,  snake_case_				)
	return tmp_dir







class        SCREAMING_SNAKE_CASE      (	UpperCamelCase_ ):






					"""simple docstring"""



					@classmethod
					def  __lowerCAmelCase				( cls    :       Any	):
						logging.disable(logging.CRITICAL	)  # remove noisy download output from tracebacks
						return cls







					@slow
					@require_torch_gpu
					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						lowerCAmelCase__			:		Union[str, Any]						       =			list_models()
						lowerCAmelCase__			:		List[Any]						       =			'''sshleifer'''
						lowerCAmelCase__			:		Tuple						       =			[x.modelId for x in model_list if x.modelId.startswith(__UpperCamelCase	)]
						lowerCAmelCase__			:		str						       =			['''sshleifer/blenderbot-3B''', '''sshleifer/blenderbot-90M''']
						lowerCAmelCase__			:		Any						       =			[]
						for m in model_ids:
							if m in allowed_to_be_broken:
								continue
							try:
								AutoConfig.from_pretrained(__UpperCamelCase	)
							except Exception:
								failures.append(__UpperCamelCase	)
						assert not failures, F'The following models could not be loaded through AutoConfig: {failures}'







					def  __lowerCAmelCase				( self    :       List[Any]	):
						lowerCAmelCase__			:		Optional[int]						       =			{'''student_encoder_layers''': 2, '''student_decoder_layers''': 1, '''no_teacher''': True}
						self._test_distiller_cli(__UpperCamelCase	)







					def  __lowerCAmelCase				( self    :       Tuple	):
						lowerCAmelCase__			:		Optional[Any]						       =			{
						    '''student_encoder_layers''': 2,
						    '''student_decoder_layers''': 1,
						    '''max_epochs''': 4,
						    '''val_check_interval''': 0.25,
						    '''alpha_hid''': 2.0,
						    '''model_name_or_path''': '''IGNORE_THIS_IT_DOESNT_GET_USED''',
						}
						lowerCAmelCase__			:		int						       =			self._test_distiller_cli(__UpperCamelCase     ,check_contents=__UpperCamelCase	)

						lowerCAmelCase__			:		Any						       =			list(Path(model.output_dir	).glob('''*.ckpt'''	)	)
						self.assertEqual(1     ,len(__UpperCamelCase	)	)
						lowerCAmelCase__			:		int						       =			list(Path(model.output_dir	).glob('''**/*.bin'''	)	)
						self.assertEqual(len(__UpperCamelCase	)     ,2	)
						lowerCAmelCase__			:		Dict						       =			lmap(str.strip     ,Path(model.hparams.data_dir	).joinpath('''test.source'''	).open().readlines()	)
						lowerCAmelCase__			:		int						       =			tempfile.mktemp()  # XXX: not being cleaned up
						generate_summaries_or_translations(__UpperCamelCase     ,__UpperCamelCase     ,str(model.output_dir / '''best_tfmr'''	)	)
						self.assertTrue(Path(__UpperCamelCase	).exists()	)

						lowerCAmelCase__			:		int						       =			self.get_auto_remove_tmp_dir()
						convert_pl_to_hf(ckpts[0]     ,transformer_ckpts[0].parent     ,__UpperCamelCase	)
						assert os.path.exists(os.path.join(__UpperCamelCase     ,'''pytorch_model.bin'''	)	)







					def  __lowerCAmelCase				( self    :       Union[str, Any]	):
						lowerCAmelCase__			:		int						       =			AutoModelForSeqaSeqLM.from_pretrained(__UpperCamelCase	)
						lowerCAmelCase__			:		int						       =			model.dummy_inputs['''input_ids'''], model.dummy_inputs['''attention_mask''']
						lowerCAmelCase__			:		Optional[int]						       =			torch.tensor([[0, 4, 8, 2], [0, 8, 2, 1]]     ,dtype=torch.long     ,device=model.device	)
						lowerCAmelCase__			:		int						       =			target_ids[:, :-1].contiguous()  # Why this line?
						lowerCAmelCase__			:		Optional[int]						       =			target_ids[:, 1:].clone()  # why clone?
						lowerCAmelCase__			:		str						       =			model(
						    __UpperCamelCase     ,attention_mask=__UpperCamelCase     ,decoder_input_ids=__UpperCamelCase     ,labels=__UpperCamelCase     ,use_cache=__UpperCamelCase	).loss

						lowerCAmelCase__			:		int						       =			model(__UpperCamelCase     ,attention_mask=__UpperCamelCase     ,decoder_input_ids=__UpperCamelCase     ,use_cache=__UpperCamelCase	).logits

						lowerCAmelCase__			:		Optional[Any]						       =			nn.functional.log_softmax(__UpperCamelCase     ,dim=-1	)
						lowerCAmelCase__			:		Dict						       =			label_smoothed_nll_loss(
						    __UpperCamelCase     ,__UpperCamelCase     ,0.1     ,ignore_index=model.config.pad_token_id	)
						with self.assertRaises(__UpperCamelCase	):
							# TODO: understand why this breaks
							self.assertEqual(__UpperCamelCase     ,__UpperCamelCase	)







					def  __lowerCAmelCase				( self    :       int	):
						lowerCAmelCase__			:		Tuple						       =			{
						    '''student_encoder_layers''': 2,
						    '''student_decoder_layers''': 1,
						    '''num_train_epochs''': 4,
						    '''val_check_interval''': 0.25,
						    '''alpha_hid''': 2.0,
						    '''task''': '''translation''',
						    '''model_name_or_path''': '''IGNORE_THIS_IT_DOESNT_GET_USED''',
						    '''tokenizer_name''': MBART_TINY,
						    '''teacher''': MBART_TINY,
						    '''src_lang''': '''en_XX''',
						    '''tgt_lang''': '''ro_RO''',
						}
						lowerCAmelCase__			:		int						       =			self._test_distiller_cli(__UpperCamelCase     ,check_contents=__UpperCamelCase	)
						assert model.model.config.model_type == "mbart"

						lowerCAmelCase__			:		List[Any]						       =			list(Path(model.output_dir	).glob('''*.ckpt'''	)	)
						self.assertEqual(1     ,len(__UpperCamelCase	)	)
						lowerCAmelCase__			:		List[Any]						       =			list(Path(model.output_dir	).glob('''**/*.bin'''	)	)
						lowerCAmelCase__			:		int						       =			list(Path(model.output_dir	).glob('''best_tfmr/*'''	)	)
						assert len(__UpperCamelCase	) > 2
						self.assertEqual(len(__UpperCamelCase	)     ,2	)







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		str						       =			{
						    '''student_encoder_layers''': 1,
						    '''student_decoder_layers''': 1,
						    '''alpha_hid''': 2.0,
						    '''teacher''': T5_TINY,
						    '''model_name_or_path''': T5_TINY,
						    '''tokenizer_name''': T5_TINY,
						}
						self._test_distiller_cli(__UpperCamelCase	)







					def  __lowerCAmelCase				( self    :       Any	):
						lowerCAmelCase__			:		int						       =			{
						    '''teacher''': T5_TINY,
						    '''student''': T5_TINIER,
						    '''model_name_or_path''': T5_TINIER,
						    '''tokenizer_name''': T5_TINIER,
						}
						self._test_distiller_cli(__UpperCamelCase	)







					def  __lowerCAmelCase				( self    :       List[Any]     ,lowercase_    :       Dict     ,lowercase_    :       Any=True	):
						lowerCAmelCase__			:		Tuple						       =			{
						    '''label_smoothing''': 0.0,
						    '''early_stopping_patience''': -1,
						    '''train_batch_size''': 1,
						    '''eval_batch_size''': 2,
						    '''max_epochs''': 2,
						    '''alpha_mlm''': 0.2,
						    '''alpha_ce''': 0.8,
						    '''do_predict''': True,
						    '''model_name_or_path''': '''sshleifer/tinier_bart''',
						    '''teacher''': CHEAP_ARGS['''model_name_or_path'''],
						    '''val_check_interval''': 0.5,
						}
						default_updates.update(__UpperCamelCase	)
						lowerCAmelCase__			:		dict						       =			CHEAP_ARGS.copy()
						lowerCAmelCase__			:		str						       =			make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()	)
						lowerCAmelCase__			:		Any						       =			self.get_auto_remove_tmp_dir()

						args_d.update(data_dir=__UpperCamelCase     ,output_dir=__UpperCamelCase     ,**__UpperCamelCase	)
						lowerCAmelCase__			:		List[str]						       =			distill_main(argparse.Namespace(**__UpperCamelCase	)	)
						if not check_contents:
							return model
						lowerCAmelCase__			:		Optional[int]						       =			os.listdir(__UpperCamelCase	)
						lowerCAmelCase__			:		Union[str, Any]						       =			{os.path.basename(__UpperCamelCase	) for p in contents}
						lowerCAmelCase__			:		int						       =			[p for p in contents if p.endswith('''ckpt'''	)]
						assert len(__UpperCamelCase	) > 0

						self.assertIn('''test_generations.txt'''     ,__UpperCamelCase	)
						self.assertIn('''test_results.txt'''     ,__UpperCamelCase	)

						lowerCAmelCase__			:		Optional[int]						       =			load_json(model.metrics_save_path	)
						lowerCAmelCase__			:		Optional[int]						       =			metrics['''val'''][-1]
						self.assertGreaterEqual(last_step_stats['''val_avg_gen_time''']     ,0.01	)
						self.assertGreaterEqual(1.0     ,last_step_stats['''val_avg_gen_time''']	)
						self.assertIsInstance(last_step_stats[F'val_avg_{model.val_metric}']     ,__UpperCamelCase	)
						lowerCAmelCase__			:		Optional[Any]						       =			int(args_d['''max_epochs'''] * (1 / args_d['''val_check_interval''']) + 1	)
						self.assertEqual(len(metrics['''val''']	)     ,__UpperCamelCase	)
						self.assertEqual(len(metrics['''test''']	)     ,1	)
						return model







class        SCREAMING_SNAKE_CASE      (	UpperCamelCase_ ):






					"""simple docstring"""



					@parameterized.expand(
					    [T5_TINY, BART_TINY, MBART_TINY, MARIAN_TINY, FSMT_TINY]     ,)
					def  __lowerCAmelCase				( self    :       int     ,lowercase_    :       int	):
						lowerCAmelCase__			:		dict						       =			CHEAP_ARGS.copy()
						lowerCAmelCase__			:		List[Any]						       =			'''translation''' if model in [MBART_TINY, MARIAN_TINY, FSMT_TINY] else '''summarization'''
						lowerCAmelCase__			:		List[Any]						       =			0.1 if task == '''translation''' else 0

						lowerCAmelCase__			:		Union[str, Any]						       =			make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()	)
						lowerCAmelCase__			:		Optional[int]						       =			self.get_auto_remove_tmp_dir()
						args_d.update(
						    data_dir=__UpperCamelCase     ,model_name_or_path=__UpperCamelCase     ,tokenizer_name=__UpperCamelCase     ,train_batch_size=2     ,eval_batch_size=2     ,output_dir=__UpperCamelCase     ,do_predict=__UpperCamelCase     ,task=__UpperCamelCase     ,src_lang='''en_XX'''     ,tgt_lang='''ro_RO'''     ,freeze_encoder=__UpperCamelCase     ,freeze_embeds=__UpperCamelCase     ,)
						assert "n_train" in args_d
						lowerCAmelCase__			:		Tuple						       =			argparse.Namespace(**__UpperCamelCase	)
						lowerCAmelCase__			:		Union[str, Any]						       =			main(__UpperCamelCase	)

						lowerCAmelCase__			:		List[str]						       =			module.model.get_input_embeddings()
						assert not input_embeds.weight.requires_grad
						if model == T5_TINY:
							lowerCAmelCase__			:		Optional[int]						       =			module.model.lm_head
							assert not lm_head.weight.requires_grad
							assert (lm_head.weight == input_embeds.weight).all().item()
						elif model == FSMT_TINY:
							lowerCAmelCase__			:		str						       =			module.model.model
							lowerCAmelCase__			:		Optional[int]						       =			fsmt.decoder.embed_positions
							assert not embed_pos.weight.requires_grad
							assert not fsmt.decoder.embed_tokens.weight.requires_grad
							# check that embeds are not the same
							assert fsmt.decoder.embed_tokens != fsmt.encoder.embed_tokens
						else:
							lowerCAmelCase__			:		Union[str, Any]						       =			module.model.model
							lowerCAmelCase__			:		List[Any]						       =			bart.decoder.embed_positions
							assert not embed_pos.weight.requires_grad
							assert not bart.shared.weight.requires_grad
							# check that embeds are the same
							assert bart.decoder.embed_tokens == bart.encoder.embed_tokens
							assert bart.decoder.embed_tokens == bart.shared

						lowerCAmelCase__			:		Optional[Any]						       =			load_json(module.output_dir / '''text_batch.json'''	)
						assert isinstance(__UpperCamelCase     ,__UpperCamelCase	)
						assert len(__UpperCamelCase	) >= 4







					def  __lowerCAmelCase				( self    :       Tuple	):
						lowerCAmelCase__			:		dict						       =			CHEAP_ARGS.copy()

						lowerCAmelCase__			:		Optional[Any]						       =			'''summarization'''
						lowerCAmelCase__			:		int						       =			make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()	)

						args_d.update(
						    data_dir=__UpperCamelCase     ,tokenizer_name=__UpperCamelCase     ,train_batch_size=2     ,eval_batch_size=2     ,do_predict=__UpperCamelCase     ,task=__UpperCamelCase     ,src_lang='''en_XX'''     ,tgt_lang='''ro_RO'''     ,freeze_encoder=__UpperCamelCase     ,freeze_embeds=__UpperCamelCase     ,)

						# test models whose config includes the extra_model_args
						lowerCAmelCase__			:		int						       =			BART_TINY
						lowerCAmelCase__			:		Tuple						       =			self.get_auto_remove_tmp_dir()
						lowerCAmelCase__			:		Optional[Any]						       =			args_d.copy()
						args_da.update(
						    model_name_or_path=__UpperCamelCase     ,output_dir=__UpperCamelCase     ,)
						lowerCAmelCase__			:		str						       =			('''encoder_layerdrop''', '''decoder_layerdrop''', '''dropout''', '''attention_dropout''')
						for p in extra_model_params:
							lowerCAmelCase__			:		Any						       =			0.5
						lowerCAmelCase__			:		Union[str, Any]						       =			argparse.Namespace(**__UpperCamelCase	)
						lowerCAmelCase__			:		Optional[Any]						       =			main(__UpperCamelCase	)
						for p in extra_model_params:
							assert getattr(model.config     ,__UpperCamelCase	) == 0.5, F'failed to override the model config for param {p}'

						# test models whose config doesn't include the extra_model_args
						lowerCAmelCase__			:		Dict						       =			T5_TINY
						lowerCAmelCase__			:		Any						       =			self.get_auto_remove_tmp_dir()
						lowerCAmelCase__			:		Dict						       =			args_d.copy()
						args_da.update(
						    model_name_or_path=__UpperCamelCase     ,output_dir=__UpperCamelCase     ,)
						lowerCAmelCase__			:		Dict						       =			'''encoder_layerdrop'''
						lowerCAmelCase__			:		Any						       =			0.5
						lowerCAmelCase__			:		str						       =			argparse.Namespace(**__UpperCamelCase	)
						with pytest.raises(__UpperCamelCase	) as excinfo:
							lowerCAmelCase__			:		List[Any]						       =			main(__UpperCamelCase	)
						assert str(excinfo.value	) == F'model config doesn\'t have a `{unsupported_param}` attribute'







					def  __lowerCAmelCase				( self    :       Any	):
						lowerCAmelCase__			:		dict						       =			CHEAP_ARGS.copy()

						lowerCAmelCase__			:		Tuple						       =			'''summarization'''
						lowerCAmelCase__			:		Optional[int]						       =			make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()	)

						lowerCAmelCase__			:		List[str]						       =			BART_TINY
						lowerCAmelCase__			:		Tuple						       =			self.get_auto_remove_tmp_dir()

						args_d.update(
						    data_dir=__UpperCamelCase     ,model_name_or_path=__UpperCamelCase     ,output_dir=__UpperCamelCase     ,tokenizer_name=__UpperCamelCase     ,train_batch_size=2     ,eval_batch_size=2     ,do_predict=__UpperCamelCase     ,task=__UpperCamelCase     ,src_lang='''en_XX'''     ,tgt_lang='''ro_RO'''     ,freeze_encoder=__UpperCamelCase     ,freeze_embeds=__UpperCamelCase     ,)

						# emulate finetune.py
						lowerCAmelCase__			:		str						       =			argparse.ArgumentParser()
						lowerCAmelCase__			:		List[Any]						       =			pl.Trainer.add_argparse_args(__UpperCamelCase	)
						lowerCAmelCase__			:		Any						       =			SummarizationModule.add_model_specific_args(__UpperCamelCase     ,os.getcwd()	)
						lowerCAmelCase__			:		Optional[int]						       =			{'''--help''': True}

						# --help test
						with pytest.raises(__UpperCamelCase	) as excinfo:
							with CaptureStdout() as cs:
								lowerCAmelCase__			:		str						       =			parser.parse_args(__UpperCamelCase	)
							assert False, "--help is expected to sys.exit"
						assert excinfo.type == SystemExit
						lowerCAmelCase__			:		List[Any]						       =			lightning_base.arg_to_scheduler_metavar
						assert expected in cs.out, "--help is expected to list the supported schedulers"

						# --lr_scheduler=non_existing_scheduler test
						lowerCAmelCase__			:		int						       =			'''non_existing_scheduler'''
						lowerCAmelCase__			:		int						       =			{F'--lr_scheduler={unsupported_param}'}
						with pytest.raises(__UpperCamelCase	) as excinfo:
							with CaptureStderr() as cs:
								lowerCAmelCase__			:		int						       =			parser.parse_args(__UpperCamelCase	)
							assert False, "invalid argument is expected to sys.exit"
						assert excinfo.type == SystemExit
						lowerCAmelCase__			:		Dict						       =			F'invalid choice: \'{unsupported_param}\''
						assert expected in cs.err, F'should have bailed on invalid choice of scheduler {unsupported_param}'

						# --lr_scheduler=existing_scheduler test
						lowerCAmelCase__			:		Any						       =			'''cosine'''
						lowerCAmelCase__			:		Union[str, Any]						       =			args_d.copy()
						lowerCAmelCase__			:		Union[str, Any]						       =			supported_param
						lowerCAmelCase__			:		str						       =			argparse.Namespace(**__UpperCamelCase	)
						lowerCAmelCase__			:		Union[str, Any]						       =			main(__UpperCamelCase	)
						assert (
						    getattr(model.hparams     ,'''lr_scheduler'''	) == supported_param
						), F'lr_scheduler={supported_param} shouldn\'t fail'







"""simple docstring"""





from cva import COLOR_BGR2GRAY, cvtColor, imread, imshow, waitKey
from numpy import divide, inta, multiply, ravel, sort, zeros_like

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_=3				):
	lowerCAmelCase__			:		Union[str, Any]						       =			int(mask / 2				)
	# copy image size
	lowerCAmelCase__			:		Dict						       =			zeros_like(A_				)
	for i in range(A_		,  gray_img.shape[0] - bd				):
		for j in range(A_		,  gray_img.shape[1] - bd				):
			# get mask according with mask
			lowerCAmelCase__			:		str						       =			ravel(gray_img[i - bd : i + bd + 1, j - bd : j + bd + 1]				)
			# calculate mask median
			lowerCAmelCase__			:		str						       =			sort(A_				)[inta(divide((multiply(A_		,  A_				))		,  2				) + 1				)]
			lowerCAmelCase__			:		List[str]						       =			median
	return median_img


if __name__ == "__main__":
							# read original image
							__UpperCamelCase						:   Dict							   =	imread('''../image_data/lena.jpg''')
							# turn image in gray scale value
							__UpperCamelCase						:   Optional[Any]							   =	cvtColor(img, COLOR_BGR2GRAY)

							# get values with two different mask size
							__UpperCamelCase						:   int							   =	median_filter(gray, 3)
							__UpperCamelCase						:   Tuple							   =	median_filter(gray, 5)

							# show result images
							imshow('''median filter with 3x3 mask''', medianaxa)
							imshow('''median filter with 5x5 mask''', medianaxa)
							waitKey(0)




