



import argparse
import json
import pickle
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
_lowercase  				=    logging.get_logger(__name__)






def   _A					(UpperCamelCase		:   str			)	->List[Any]:



			'''simple docstring'''







			lowerCamelCase__			:   Tuple										=		SwinConfig.from_pretrained(
			    """microsoft/swin-tiny-patch4-window7-224"""   ,      out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]			)
			lowerCamelCase__			:   Dict										=		MaskFormerConfig(backbone_config=__a			)

			lowerCamelCase__			:   Optional[Any]										=		'''huggingface/label-files'''
			if "ade20k-full" in model_name:
						# this should be ok
						lowerCamelCase__			:   Optional[Any]										=		847
						lowerCamelCase__			:   List[Any]										=		'''maskformer-ade20k-full-id2label.json'''
			elif "ade" in model_name:
						# this should be ok
						lowerCamelCase__			:   Union[str, Any]										=		150
						lowerCamelCase__			:   Any										=		'''ade20k-id2label.json'''
			elif "coco-stuff" in model_name:
						# this should be ok
						lowerCamelCase__			:   int										=		171
						lowerCamelCase__			:   List[str]										=		'''maskformer-coco-stuff-id2label.json'''
			elif "coco" in model_name:
						# TODO
						lowerCamelCase__			:   Dict										=		133
						lowerCamelCase__			:   Optional[Any]										=		'''coco-panoptic-id2label.json'''
			elif "cityscapes" in model_name:
						# this should be ok
						lowerCamelCase__			:   List[Any]										=		19
						lowerCamelCase__			:   Optional[Any]										=		'''cityscapes-id2label.json'''
			elif "vistas" in model_name:
						# this should be ok
						lowerCamelCase__			:   List[Any]										=		65
						lowerCamelCase__			:   Dict										=		'''mapillary-vistas-id2label.json'''

			lowerCamelCase__			:   Optional[int]										=		json.load(open(hf_hub_download(__a   ,      __a   ,      repo_type="""dataset"""			)   ,      """r"""			)			)
			lowerCamelCase__			:   Tuple										=		{int(__a			): v for k, v in idalabel.items()}

			return config






def   _A					(UpperCamelCase		:   Optional[Any]			)	->Tuple:



			'''simple docstring'''







			lowerCamelCase__			:   Optional[Any]										=		[]
			# stem
			# fmt: off
			rename_keys.append(("""backbone.patch_embed.proj.weight""", """model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight""")			)
			rename_keys.append(("""backbone.patch_embed.proj.bias""", """model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias""")			)
			rename_keys.append(("""backbone.patch_embed.norm.weight""", """model.pixel_level_module.encoder.model.embeddings.norm.weight""")			)
			rename_keys.append(("""backbone.patch_embed.norm.bias""", """model.pixel_level_module.encoder.model.embeddings.norm.bias""")			)
			# stages
			for i in range(len(config.backbone_config.depths			)			):
						for j in range(config.backbone_config.depths[i]			):
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm1.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm1.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.relative_position_index", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.proj.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.proj.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm2.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm2.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc1.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc1.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc2.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight")			)
									rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc2.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias")			)

						if i < 3:
									rename_keys.append((f"backbone.layers.{i}.downsample.reduction.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight")			)
									rename_keys.append((f"backbone.layers.{i}.downsample.norm.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight")			)
									rename_keys.append((f"backbone.layers.{i}.downsample.norm.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias")			)
						rename_keys.append((f"backbone.norm{i}.weight", f"model.pixel_level_module.encoder.hidden_states_norms.{i}.weight")			)
						rename_keys.append((f"backbone.norm{i}.bias", f"model.pixel_level_module.encoder.hidden_states_norms.{i}.bias")			)

			# FPN
			rename_keys.append(("""sem_seg_head.layer_4.weight""", """model.pixel_level_module.decoder.fpn.stem.0.weight""")			)
			rename_keys.append(("""sem_seg_head.layer_4.norm.weight""", """model.pixel_level_module.decoder.fpn.stem.1.weight""")			)
			rename_keys.append(("""sem_seg_head.layer_4.norm.bias""", """model.pixel_level_module.decoder.fpn.stem.1.bias""")			)
			for source_index, target_index in zip(range(3   ,      0   ,      -1			)   ,      range(0   ,      3			)			):
						rename_keys.append((f"sem_seg_head.adapter_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight")			)
						rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight")			)
						rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias")			)
						rename_keys.append((f"sem_seg_head.layer_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight")			)
						rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight")			)
						rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias")			)
			rename_keys.append(("""sem_seg_head.mask_features.weight""", """model.pixel_level_module.decoder.mask_projection.weight""")			)
			rename_keys.append(("""sem_seg_head.mask_features.bias""", """model.pixel_level_module.decoder.mask_projection.bias""")			)

			# Transformer decoder
			for idx in range(config.decoder_config.decoder_layers			):
						# self-attention out projection
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias")			)
						# cross-attention out projection
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias")			)
						# MLP 1
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight", f"model.transformer_module.decoder.layers.{idx}.fc1.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias", f"model.transformer_module.decoder.layers.{idx}.fc1.bias")			)
						# MLP 2
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight", f"model.transformer_module.decoder.layers.{idx}.fc2.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias", f"model.transformer_module.decoder.layers.{idx}.fc2.bias")			)
						# layernorm 1 (self-attention layernorm)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias")			)
						# layernorm 2 (cross-attention layernorm)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias")			)
						# layernorm 3 (final layernorm)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias")			)

			rename_keys.append(("""sem_seg_head.predictor.transformer.decoder.norm.weight""", """model.transformer_module.decoder.layernorm.weight""")			)
			rename_keys.append(("""sem_seg_head.predictor.transformer.decoder.norm.bias""", """model.transformer_module.decoder.layernorm.bias""")			)

			# heads on top
			rename_keys.append(("""sem_seg_head.predictor.query_embed.weight""", """model.transformer_module.queries_embedder.weight""")			)

			rename_keys.append(("""sem_seg_head.predictor.input_proj.weight""", """model.transformer_module.input_projection.weight""")			)
			rename_keys.append(("""sem_seg_head.predictor.input_proj.bias""", """model.transformer_module.input_projection.bias""")			)

			rename_keys.append(("""sem_seg_head.predictor.class_embed.weight""", """class_predictor.weight""")			)
			rename_keys.append(("""sem_seg_head.predictor.class_embed.bias""", """class_predictor.bias""")			)

			for i in range(3			):
						rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.weight", f"mask_embedder.{i}.0.weight")			)
						rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.bias", f"mask_embedder.{i}.0.bias")			)
			# fmt: on

			return rename_keys






def   _A					(UpperCamelCase		:   List[str]   ,      UpperCamelCase		:   List[Any]   ,      UpperCamelCase		:   Optional[Any]			)	->Union[str, Any]:



			'''simple docstring'''







			lowerCamelCase__			:   str										=		dct.pop(__a			)
			lowerCamelCase__			:   str										=		val






def   _A					(UpperCamelCase		:   List[Any]   ,      UpperCamelCase		:   Union[str, Any]			)	->Union[str, Any]:



			'''simple docstring'''







			lowerCamelCase__			:   Union[str, Any]										=		[int(backbone_config.embed_dim * 2**i			) for i in range(len(backbone_config.depths			)			)]
			for i in range(len(backbone_config.depths			)			):
						lowerCamelCase__			:   Optional[Any]										=		num_features[i]
						for j in range(backbone_config.depths[i]			):
									# fmt: off
									# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
									lowerCamelCase__			:   List[Any]										=		state_dict.pop(f"backbone.layers.{i}.blocks.{j}.attn.qkv.weight"			)
									lowerCamelCase__			:   Optional[int]										=		state_dict.pop(f"backbone.layers.{i}.blocks.{j}.attn.qkv.bias"			)
									# next, add query, keys and values (in that order) to the state dict
									lowerCamelCase__			:   Optional[int]										=		in_proj_weight[:dim, :]
									lowerCamelCase__			:   List[Any]										=		in_proj_bias[: dim]
									lowerCamelCase__			:   Optional[int]										=		in_proj_weight[
									    dim : dim * 2, :
									]
									lowerCamelCase__			:   Tuple										=		in_proj_bias[
									    dim : dim * 2
									]
									lowerCamelCase__			:   int										=		in_proj_weight[
									    -dim :, :
									]
									lowerCamelCase__			:   Optional[int]										=		in_proj_bias[-dim :]
									# fmt: on






def   _A					(UpperCamelCase		:   List[str]   ,      UpperCamelCase		:   List[Any]			)	->List[Any]:



			'''simple docstring'''







			lowerCamelCase__			:   Optional[int]										=		config.decoder_config.hidden_size
			for idx in range(config.decoder_config.decoder_layers			):
						# read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
						lowerCamelCase__			:   Union[str, Any]										=		state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight"			)
						lowerCamelCase__			:   List[Any]										=		state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias"			)
						# next, add query, keys and values (in that order) to the state dict
						lowerCamelCase__			:   Union[str, Any]										=		in_proj_weight[: hidden_size, :]
						lowerCamelCase__			:   List[Any]										=		in_proj_bias[:config.hidden_size]
						lowerCamelCase__			:   Dict										=		in_proj_weight[hidden_size : hidden_size * 2, :]
						lowerCamelCase__			:   Any										=		in_proj_bias[hidden_size : hidden_size * 2]
						lowerCamelCase__			:   Tuple										=		in_proj_weight[-hidden_size :, :]
						lowerCamelCase__			:   List[Any]										=		in_proj_bias[-hidden_size :]
						# read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
						lowerCamelCase__			:   List[Any]										=		state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight"			)
						lowerCamelCase__			:   List[str]										=		state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias"			)
						# next, add query, keys and values (in that order) to the state dict
						lowerCamelCase__			:   Optional[Any]										=		in_proj_weight[: hidden_size, :]
						lowerCamelCase__			:   Any										=		in_proj_bias[:config.hidden_size]
						lowerCamelCase__			:   List[str]										=		in_proj_weight[hidden_size : hidden_size * 2, :]
						lowerCamelCase__			:   Optional[Any]										=		in_proj_bias[hidden_size : hidden_size * 2]
						lowerCamelCase__			:   List[str]										=		in_proj_weight[-hidden_size :, :]
						lowerCamelCase__			:   int										=		in_proj_bias[-hidden_size :]
			# fmt: on






def   _A					()	->torch.Tensor:



			'''simple docstring'''







			lowerCamelCase__			:   str										=		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
			lowerCamelCase__			:   Dict										=		Image.open(requests.get(__a   ,      stream=__a			).raw			)
			return im






@torch.no_grad()
def   _A					(UpperCamelCase		:   str   ,      UpperCamelCase		:   str   ,      UpperCamelCase		:   str   ,      UpperCamelCase		:   bool = False			)	->Union[str, Any]:



			'''simple docstring'''







			lowerCamelCase__			:   Optional[Any]										=		get_maskformer_config(__a			)

			# load original state_dict
			with open(__a   ,      """rb"""			) as f:
						lowerCamelCase__			:   str										=		pickle.load(__a			)
			lowerCamelCase__			:   Union[str, Any]										=		data['''model''']

			# for name, param in state_dict.items():
			#     print(name, param.shape)

			# rename keys
			lowerCamelCase__			:   Any										=		create_rename_keys(__a			)
			for src, dest in rename_keys:
						rename_key(__a   ,      __a   ,      __a			)
			read_in_swin_q_k_v(__a   ,      config.backbone_config			)
			read_in_decoder_q_k_v(__a   ,      __a			)

			# update to torch tensors
			for key, value in state_dict.items():
						lowerCamelCase__			:   Optional[int]										=		torch.from_numpy(__a			)

			# load 🤗 model
			lowerCamelCase__			:   Dict										=		MaskFormerForInstanceSegmentation(__a			)
			model.eval()

			for name, param in model.named_parameters():
						print(__a   ,      param.shape			)

			lowerCamelCase__			:   Tuple										=		model.load_state_dict(__a   ,      strict=__a			)
			assert missing_keys == [
			    "model.pixel_level_module.encoder.model.layernorm.weight",
			    "model.pixel_level_module.encoder.model.layernorm.bias",
			]
			assert len(__a			) == 0, f"Unexpected keys: {unexpected_keys}"

			# verify results
			lowerCamelCase__			:   Union[str, Any]										=		prepare_img()
			if "vistas" in model_name:
						lowerCamelCase__			:   int										=		65
			elif "cityscapes" in model_name:
						lowerCamelCase__			:   Tuple										=		65535
			else:
						lowerCamelCase__			:   str										=		255
			lowerCamelCase__			:   Dict										=		True if '''ade''' in model_name else False
			lowerCamelCase__			:   Optional[Any]										=		MaskFormerImageProcessor(ignore_index=__a   ,      reduce_labels=__a			)

			lowerCamelCase__			:   Optional[Any]										=		image_processor(__a   ,      return_tensors="""pt"""			)

			lowerCamelCase__			:   int										=		model(**__a			)

			print("""Logits:"""   ,      outputs.class_queries_logits[0, :3, :3]			)

			if model_name == "maskformer-swin-tiny-ade":
						lowerCamelCase__			:   Union[str, Any]										=		torch.tensor(
						    [[3.6_353, -4.4_770, -2.6_065], [0.5_081, -4.2_394, -3.5_343], [2.1_909, -5.0_353, -1.9_323]]			)
			assert torch.allclose(outputs.class_queries_logits[0, :3, :3]   ,      __a   ,      atol=1E-4			)
			print("""Looks ok!"""			)

			if pytorch_dump_folder_path is not None:
						print(f"Saving model and image processor to {pytorch_dump_folder_path}"			)
						Path(__a			).mkdir(exist_ok=__a			)
						model.save_pretrained(__a			)
						image_processor.save_pretrained(__a			)

			if push_to_hub:
						print("""Pushing model and image processor to the hub..."""			)
						model.push_to_hub(f"nielsr/{model_name}"			)
						image_processor.push_to_hub(f"nielsr/{model_name}"			)


if __name__ == "__main__":
				_lowercase  				=    argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--model_name''',
				    default='''maskformer-swin-tiny-ade''',
				    type=str,
				    help=('''Name of the MaskFormer model you\'d like to convert''',),
				)
				parser.add_argument(
				    '''--checkpoint_path''',
				    default='''/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl''',
				    type=str,
				    help='''Path to the original state dict (.pth file).''',
				)
				parser.add_argument(
				    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
				)
				parser.add_argument(
				    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
				)

				_lowercase  				=    parser.parse_args()
				convert_maskformer_checkpoint(
				    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
				)






from __future__ import annotations

import matplotlib.pyplot as plt  # type: ignore
import numpy

# initial triangle of Koch snowflake
a__												=						numpy.array([0, 0])
a__												=						numpy.array([0.5, 0.8660254])
a__												=						numpy.array([1, 0])
a__												=						[VECTOR_1, VECTOR_2, VECTOR_3, VECTOR_1]



def   __UpperCAmelCase					(      __a :     list[numpy.ndarray]						,__a :     int      )     ->	list[numpy.ndarray]:

					"""simple docstring"""

					_a      :       Tuple   =						initial_vectors
					for _ in range(__a      ):
										_a      :       int   =						iteration_step(__a      )
					return vectors



def   __UpperCAmelCase					(      __a :     list[numpy.ndarray]      )     ->	list[numpy.ndarray]:

					"""simple docstring"""

					_a      :       Tuple   =						[]
					for i, start_vector in enumerate(vectors[:-1]      ):
										_a      :       str   =						vectors[i + 1]
										new_vectors.append(__a      )
										_a      :       Optional[int]   =						end_vector - start_vector
										new_vectors.append(start_vector + difference_vector / 3      )
										new_vectors.append(
										    start_vector + difference_vector / 3 + rotate(difference_vector / 3						,60      )      )
										new_vectors.append(start_vector + difference_vector * 2 / 3      )
					new_vectors.append(vectors[-1]      )
					return new_vectors



def   __UpperCAmelCase					(      __a :     numpy.ndarray						,__a :     float      )     ->	numpy.ndarray:

					"""simple docstring"""

					_a      :       Tuple   =						numpy.radians(__a      )
					_a ,   _a      :       List[Any]   =						numpy.cos(__a      ), numpy.sin(__a      )
					_a      :       Dict   =						numpy.array(((c, -s), (s, c))      )
					return numpy.dot(__a						,__a      )



def   __UpperCAmelCase					(      __a :     list[numpy.ndarray]      )     ->	None:

					"""simple docstring"""

					_a      :       str   =						plt.gca()
					axes.set_aspect('''equal'''      )

					# matplotlib.pyplot.plot takes a list of all x-coordinates and a list of all
					# y-coordinates as inputs, which are constructed from the vector-list using
					# zip()
					_a ,   _a      :       Optional[int]   =						zip(*__a      )
					plt.plot(__a						,__a      )
					plt.show()


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			a__												=						iterate(INITIAL_VECTORS, 5)
			plot(processed_vectors)



