






'''simple docstring'''





import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ConvNextConfig, UperNetConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import UperNetForSemanticSegmentation
	from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor
class 				lowercase       :


				'''simple docstring'''

				def __init__(					self     :     Optional[Any]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     Optional[Any]=13				,     __lowerCamelCase     :     Optional[Any]=32				,     __lowerCamelCase     :     Union[str, Any]=3				,     __lowerCamelCase     :     List[Any]=4				,     __lowerCamelCase     :     List[str]=[10, 20, 30, 40]				,     __lowerCamelCase     :     Tuple=[2, 2, 3, 2]				,     __lowerCamelCase     :     int=True				,     __lowerCamelCase     :     List[str]=True				,     __lowerCamelCase     :     Dict=37				,     __lowerCamelCase     :     Optional[int]="gelu"				,     __lowerCamelCase     :     Dict=10				,     __lowerCamelCase     :     Optional[Any]=0.0_2				,     __lowerCamelCase     :     Any=["stage2", "stage3", "stage4"]				,     __lowerCamelCase     :     List[Any]=3				,     __lowerCamelCase     :     Any=None				,     )							->							str:

					'''simple docstring'''




					lowerCamelCase__  =     parent
					lowerCamelCase__  =     batch_size
					lowerCamelCase__  =     image_size
					lowerCamelCase__  =     num_channels
					lowerCamelCase__  =     num_stages
					lowerCamelCase__  =     hidden_sizes
					lowerCamelCase__  =     depths
					lowerCamelCase__  =     is_training
					lowerCamelCase__  =     use_labels
					lowerCamelCase__  =     intermediate_size
					lowerCamelCase__  =     hidden_act
					lowerCamelCase__  =     type_sequence_label_size
					lowerCamelCase__  =     initializer_range
					lowerCamelCase__  =     out_features
					lowerCamelCase__  =     num_labels
					lowerCamelCase__  =     scope
					lowerCamelCase__  =     num_stages

				def    a__				(					self     :     List[str]     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

					lowerCamelCase__  =     None
					if self.use_labels:
						lowerCamelCase__  =     ids_tensor([self.batch_size]				,     self.type_sequence_label_size     )

					lowerCamelCase__  =     self.get_config()

					return config, pixel_values, labels

				def    a__				(					self     :     Dict     )							->							List[Any]:

					'''simple docstring'''




					return ConvNextConfig(
					    num_channels=self.num_channels				,     num_stages=self.num_stages				,     hidden_sizes=self.hidden_sizes				,     depths=self.depths				,     is_training=self.is_training				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     out_features=self.out_features				,     )

				def    a__				(					self     :     List[str]     )							->							str:

					'''simple docstring'''




					return UperNetConfig(
					    backbone_config=self.get_backbone_config()				,     hidden_size=512				,     pool_scales=[1, 2, 3, 6]				,     use_auxiliary_head=__A				,     auxiliary_loss_weight=0.4				,     auxiliary_in_channels=40				,     auxiliary_channels=256				,     auxiliary_num_convs=1				,     auxiliary_concat_input=__A				,     loss_ignore_index=255				,     num_labels=self.num_labels				,     )

				def    a__				(					self     :     Optional[int]				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     str				,     __lowerCamelCase     :     List[Any]     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     UperNetForSemanticSegmentation(config=__A     )
					model.to(__A     )
					model.eval()
					lowerCamelCase__  =     model(__A     )
					self.parent.assertEqual(
					    result.logits.shape				,     (self.batch_size, self.num_labels, self.image_size, self.image_size)     )




				def    a__				(					self     :     List[str]     )							->							List[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     self.prepare_config_and_inputs()
					(
					    lowerCamelCase__		
					)  =     config_and_inputs
					lowerCamelCase__  =     {"pixel_values": pixel_values}
					return config, inputs_dict
@require_torch
class 				lowercase       (							_lowerCamelCase ,       _lowerCamelCase ,       unittest.TestCase      ):


				'''simple docstring'''

				lowerCAmelCase__      				=							(UperNetForSemanticSegmentation,) if is_torch_available() else ()
				lowerCAmelCase__      				=							{"image-segmentation": UperNetForSemanticSegmentation} if is_torch_available() else {}
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False

				def    a__				(					self     :     int     )							->							List[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     UperNetModelTester(self     )
					lowerCamelCase__  =     ConfigTester(self				,     config_class=__A				,     has_text_modality=__A				,     hidden_size=37     )

				def    a__				(					self     :     Dict     )							->							Optional[Any]:

					'''simple docstring'''




					self.create_and_test_config_common_properties()
					self.config_tester.create_and_test_config_to_json_string()
					self.config_tester.create_and_test_config_to_json_file()
					self.config_tester.create_and_test_config_from_and_save_pretrained()
					self.config_tester.create_and_test_config_with_num_labels()
					self.config_tester.check_config_can_be_init_without_params()
					self.config_tester.check_config_arguments_init()

				def    a__				(					self     :     str     )							->							List[Any]:

					'''simple docstring'''




					return

				def    a__				(					self     :     int     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						lowerCamelCase__  =     model_class(__A     )
						lowerCamelCase__  =     inspect.signature(model.forward     )
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						lowerCamelCase__  =     [*signature.parameters.keys()]

						lowerCamelCase__  =     ["pixel_values"]
						self.assertListEqual(arg_names[:1]				,     __A     )

				def    a__				(					self     :     Optional[int]     )							->							str:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_semantic_segmentation(*__A     )

				@unittest.skip(reason="UperNet does not use inputs_embeds"     )
				def    a__				(					self     :     Dict     )							->							List[str]:

					'''simple docstring'''




					pass

				@unittest.skip(reason="UperNet does not support input and output embeddings"     )
				def    a__				(					self     :     List[Any]     )							->							List[Any]:

					'''simple docstring'''




					pass

				@unittest.skip(reason="UperNet does not have a base model"     )
				def    a__				(					self     :     Dict     )							->							Optional[int]:

					'''simple docstring'''




					pass

				@unittest.skip(reason="UperNet does not have a base model"     )
				def    a__				(					self     :     Union[str, Any]     )							->							str:

					'''simple docstring'''




					pass

				@require_torch_multi_gpu
				@unittest.skip(reason="UperNet has some layers using `add_module` which doesn't work well with `nn.DataParallel`"     )
				def    a__				(					self     :     Any     )							->							int:

					'''simple docstring'''




					pass

				@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."     )
				def    a__				(					self     :     Optional[Any]     )							->							int:

					'''simple docstring'''




					pass

				def    a__				(					self     :     int     )							->							Optional[int]:

					'''simple docstring'''




					def check_hidden_states_output(__lowerCamelCase     :     int				,     __lowerCamelCase     :     List[str]				,     __lowerCamelCase     :     Optional[int]     ):
						lowerCamelCase__  =     model_class(__A     )
						model.to(__A     )
						model.eval()

						with torch.no_grad():
							lowerCamelCase__  =     model(**self._prepare_for_class(__A				,     __A     )     )

						lowerCamelCase__  =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

						lowerCamelCase__  =     self.model_tester.num_stages
						self.assertEqual(len(__A     )				,     expected_num_stages + 1     )

						# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
						self.assertListEqual(
						    list(hidden_states[0].shape[-2:]     )				,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]				,     )

					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						lowerCamelCase__  =     True
						check_hidden_states_output(__A				,     __A				,     __A     )

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						lowerCamelCase__  =     True

						check_hidden_states_output(__A				,     __A				,     __A     )

				def    a__				(					self     :     List[str]     )							->							Optional[int]:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()

					lowerCamelCase__  =     _config_zero_init(__A     )
					lowerCamelCase__  =     _config_zero_init(configs_no_init.backbone_config     )
					for model_class in self.all_model_classes:
						lowerCamelCase__  =     model_class(config=__A     )
						for name, param in model.named_parameters():
							if param.requires_grad:
								self.assertIn(
								    ((param.data.mean() * 1E9).round() / 1E9).item()				,     [0.0, 1.0]				,     msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''				,     )

				@unittest.skip(reason="UperNet does not have tied weights"     )
				def    a__				(					self     :     Optional[Any]     )							->							Dict:

					'''simple docstring'''




					pass




				@slow
				def    a__				(					self     :     Any     )							->							List[str]:

					'''simple docstring'''




					for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowerCamelCase__  =     UperNetForSemanticSegmentation.from_pretrained(__A     )
						self.assertIsNotNone(__A     )






def    lowerCamelCase_     (    ):
	lowerCamelCase__  =     hf_hub_download(
	    repo_id="hf-internal-testing/fixtures_ade20k"				,     repo_type="dataset"				,     filename="ADE_val_00000001.jpg")
	lowerCamelCase__  =     Image.open(_lowerCAmelCase).convert("RGB")
	return image
@require_torch
@require_vision
@slow
class 				lowercase       (							unittest.TestCase      ):


				'''simple docstring'''

				def    a__				(					self     :     List[Any]     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     AutoImageProcessor.from_pretrained("openmmlab/upernet-swin-tiny"     )
					lowerCamelCase__  =     UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-swin-tiny"     ).to(__A     )

					lowerCamelCase__  =     prepare_img()
					lowerCamelCase__  =     processor(images=__A				,     return_tensors="pt"     ).to(__A     )

					with torch.no_grad():
						lowerCamelCase__  =     model(**__A     )

					lowerCamelCase__  =     torch.Size((1, model.config.num_labels, 512, 512)     )
					self.assertEqual(outputs.logits.shape				,     __A     )

					lowerCamelCase__  =     torch.tensor(
					    [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]     ).to(__A     )
					self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]				,     __A				,     atol=1E-4     )     )




				def    a__				(					self     :     Dict     )							->							Optional[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny"     )
					lowerCamelCase__  =     UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny"     ).to(__A     )

					lowerCamelCase__  =     prepare_img()
					lowerCamelCase__  =     processor(images=__A				,     return_tensors="pt"     ).to(__A     )

					with torch.no_grad():
						lowerCamelCase__  =     model(**__A     )

					lowerCamelCase__  =     torch.Size((1, model.config.num_labels, 512, 512)     )
					self.assertEqual(outputs.logits.shape				,     __A     )

					lowerCamelCase__  =     torch.tensor(
					    [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]]     ).to(__A     )
					self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]				,     __A				,     atol=1E-4     )     )









'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel
@require_tf
class 				lowercase       :


    '''simple docstring'''

    lowerCAmelCase__      				=							BlenderbotSmallConfig
    lowerCAmelCase__      				=							{}
    lowerCAmelCase__      				=							"gelu"

    def __init__(					self     :     List[Any]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     str=13				,     __lowerCamelCase     :     List[str]=7				,     __lowerCamelCase     :     Dict=True				,     __lowerCamelCase     :     Any=False				,     __lowerCamelCase     :     Union[str, Any]=99				,     __lowerCamelCase     :     Optional[int]=32				,     __lowerCamelCase     :     Optional[int]=2				,     __lowerCamelCase     :     List[str]=4				,     __lowerCamelCase     :     Union[str, Any]=37				,     __lowerCamelCase     :     Tuple=0.1				,     __lowerCamelCase     :     List[str]=0.1				,     __lowerCamelCase     :     int=20				,     __lowerCamelCase     :     Optional[Any]=2				,     __lowerCamelCase     :     List[str]=1				,     __lowerCamelCase     :     Union[str, Any]=0				,     )							->							str:

     '''simple docstring'''




     lowerCamelCase__  =     parent
     lowerCamelCase__  =     batch_size
     lowerCamelCase__  =     seq_length
     lowerCamelCase__  =     is_training
     lowerCamelCase__  =     use_labels
     lowerCamelCase__  =     vocab_size
     lowerCamelCase__  =     hidden_size
     lowerCamelCase__  =     num_hidden_layers
     lowerCamelCase__  =     num_attention_heads
     lowerCamelCase__  =     intermediate_size

     lowerCamelCase__  =     hidden_dropout_prob
     lowerCamelCase__  =     attention_probs_dropout_prob
     lowerCamelCase__  =     max_position_embeddings
     lowerCamelCase__  =     eos_token_id
     lowerCamelCase__  =     pad_token_id
     lowerCamelCase__  =     bos_token_id

    def    a__				(					self     :     str     )							->							List[str]:

     '''simple docstring'''




     lowerCamelCase__  =     ids_tensor([self.batch_size, self.seq_length - 1]				,     self.vocab_size     )
     lowerCamelCase__  =     tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size     )				,     1     )
     lowerCamelCase__  =     tf.concat([input_ids, eos_tensor]				,     axis=1     )

     lowerCamelCase__  =     ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size     )

     lowerCamelCase__  =     self.config_cls(
         vocab_size=self.vocab_size				,     d_model=self.hidden_size				,     encoder_layers=self.num_hidden_layers				,     decoder_layers=self.num_hidden_layers				,     encoder_attention_heads=self.num_attention_heads				,     decoder_attention_heads=self.num_attention_heads				,     encoder_ffn_dim=self.intermediate_size				,     decoder_ffn_dim=self.intermediate_size				,     dropout=self.hidden_dropout_prob				,     attention_dropout=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     eos_token_ids=[2]				,     bos_token_id=self.bos_token_id				,     pad_token_id=self.pad_token_id				,     decoder_start_token_id=self.pad_token_id				,     **self.config_updates				,     )
     lowerCamelCase__  =     prepare_blenderbot_small_inputs_dict(__lowerCamelCase				,     __lowerCamelCase				,     __lowerCamelCase     )
     return config, inputs_dict




    def    a__				(					self     :     int				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Optional[Any]     )							->							Tuple:

     '''simple docstring'''




     lowerCamelCase__  =     TFBlenderbotSmallModel(config=__lowerCamelCase     ).get_decoder()
     lowerCamelCase__  =     inputs_dict["input_ids"]

     lowerCamelCase__  =     input_ids[:1, :]
     lowerCamelCase__  =     inputs_dict["attention_mask"][:1, :]
     lowerCamelCase__  =     inputs_dict["head_mask"]
     lowerCamelCase__  =     1

     # first forward pass
     lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     head_mask=__lowerCamelCase				,     use_cache=__lowerCamelCase     )

     lowerCamelCase__  ,	lowerCamelCase__  =     outputs.to_tuple()

     # create hypothetical next token and extent to next_input_ids
     lowerCamelCase__  =     ids_tensor((self.batch_size, 3)				,     config.vocab_size     )
     lowerCamelCase__  =     tf.cast(ids_tensor((self.batch_size, 3)				,     2     )				,     tf.inta     )

     # append to next input_ids and
     lowerCamelCase__  =     tf.concat([input_ids, next_tokens]				,     axis=-1     )
     lowerCamelCase__  =     tf.concat([attention_mask, next_attn_mask]				,     axis=-1     )

     lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase     )[0]
     lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     past_key_values=__lowerCamelCase     )[0]

     self.parent.assertEqual(next_tokens.shape[1]				,     output_from_past.shape[1]     )

     # select random slice
     lowerCamelCase__  =     int(ids_tensor((1,)				,     output_from_past.shape[-1]     )     )
     lowerCamelCase__  =     output_from_no_past[:, -3:, random_slice_idx]
     lowerCamelCase__  =     output_from_past[:, :, random_slice_idx]

     # test that outputs are equal for slice
     tf.debugging.assert_near(__lowerCamelCase				,     __lowerCamelCase				,     rtol=1E-3     )






def    lowerCamelCase_     (    lowercase__				,     lowercase__				,     lowercase__				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     ):
 if attention_mask is None:
  lowerCamelCase__  =     tf.cast(tf.math.not_equal(lowercase__				,     config.pad_token_id)				,     tf.inta)
 if decoder_attention_mask is None:
  lowerCamelCase__  =     tf.concat(
      [
          tf.ones(decoder_input_ids[:, :1].shape				,     dtype=tf.inta),
          tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]				,     config.pad_token_id)				,     tf.inta),
      ]				,     axis=-1				,     )
 if head_mask is None:
  lowerCamelCase__  =     tf.ones((config.encoder_layers, config.encoder_attention_heads))
 if decoder_head_mask is None:
  lowerCamelCase__  =     tf.ones((config.decoder_layers, config.decoder_attention_heads))
 if cross_attn_head_mask is None:
  lowerCamelCase__  =     tf.ones((config.decoder_layers, config.decoder_attention_heads))
 return {
     "input_ids": input_ids,
     "decoder_input_ids": decoder_input_ids,
     "attention_mask": attention_mask,
     "decoder_attention_mask": decoder_attention_mask,
     "head_mask": head_mask,
     "decoder_head_mask": decoder_head_mask,
     "cross_attn_head_mask": cross_attn_head_mask,
 }
@require_tf
class 				lowercase       (							_lowerCamelCase ,       _lowerCamelCase ,       unittest.TestCase      ):


    '''simple docstring'''

    lowerCAmelCase__      				=							(
        (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
    )
    lowerCAmelCase__      				=							(TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
    lowerCAmelCase__      				=							(
        {
            "conversational": TFBlenderbotSmallForConditionalGeneration,
            "feature-extraction": TFBlenderbotSmallModel,
            "summarization": TFBlenderbotSmallForConditionalGeneration,
            "text2text-generation": TFBlenderbotSmallForConditionalGeneration,
            "translation": TFBlenderbotSmallForConditionalGeneration,
        }
        if is_tf_available()
        else {}
    )
    lowerCAmelCase__      				=							True
    lowerCAmelCase__      				=							False
    lowerCAmelCase__      				=							False

    def    a__				(					self     :     List[Any]     )							->							Optional[Any]:

     '''simple docstring'''




     lowerCamelCase__  =     TFBlenderbotSmallModelTester(self     )
     lowerCamelCase__  =     ConfigTester(self				,     config_class=__lowerCamelCase     )

    def    a__				(					self     :     Any     )							->							Tuple:

     '''simple docstring'''




     self.config_tester.run_common_tests()




    def    a__				(					self     :     List[Any]     )							->							List[str]:

     '''simple docstring'''




     lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()
     self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase     )
@require_tokenizers
@require_tf
class 				lowercase       (							unittest.TestCase      ):


    '''simple docstring'''

    lowerCAmelCase__      				=							[
        "Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like "
        "  i'm going to throw up.\nand why is that?"
    ]
    lowerCAmelCase__      				=							"facebook/blenderbot_small-90M"

    @cached_property
    def    a__				(					self     :     Optional[Any]     )							->							Tuple:

     '''simple docstring'''




     return BlenderbotSmallTokenizer.from_pretrained("facebook/blenderbot-90M"     )

    @cached_property
    def    a__				(					self     :     int     )							->							int:

     '''simple docstring'''




     lowerCamelCase__  =     TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name     )
     return model




    @slow
    def    a__				(					self     :     Any     )							->							Union[str, Any]:

     '''simple docstring'''




     lowerCamelCase__  =     self.tokenizer(self.src_text				,     return_tensors="tf"     )
     lowerCamelCase__  =     self.model.generate(
         model_inputs.input_ids				,     attention_mask=model_inputs.attention_mask				,     num_beams=2				,     use_cache=__lowerCamelCase				,     )
     lowerCamelCase__  =     self.tokenizer.batch_decode(generated_ids.numpy()				,     skip_special_tokens=__lowerCamelCase     )[0]
     assert generated_words in (
         "i don't know. i just feel like i'm going to throw up. it's not fun.",
         "i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
         "i'm not sure. i just feel like i've been in a bad situation.",
     )

