






"""simple docstring"""



import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

_snake_case							:   int	  =       logging.get_logger(__name__)




def     lowerCamelCase_					(	__A	:		Tuple      ,						__A	:		bool = True      ):
					lowerCamelCase__					={}
					for name in model.attn_processors.keys():
										lowerCamelCase__					=name.endswith('attn2.processor'      ) and not (
										    name.startswith('transformer_in'      ) or 'temp_attentions' in name.split('.'      )
										)
										lowerCamelCase__					=model.config.cross_attention_dim if has_cross_attention else None
										if name.startswith('mid_block'      ):
															lowerCamelCase__					=model.config.block_out_channels[-1]
										elif name.startswith('up_blocks'      ):
															lowerCamelCase__					=int(name[len('up_blocks.'      )]      )
															lowerCamelCase__					=list(reversed(model.config.block_out_channels      )      )[block_id]
										elif name.startswith('down_blocks'      ):
															lowerCamelCase__					=int(name[len('down_blocks.'      )]      )
															lowerCamelCase__					=model.config.block_out_channels[block_id]
										elif name.startswith('transformer_in'      ):
															# Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
															lowerCamelCase__					=8 * model.config.attention_head_dim

										lowerCamelCase__					=LoRAAttnProcessor(hidden_size=__A      ,						cross_attention_dim=__A      )
										lowerCamelCase__					=lora_attn_procs[name].to(model.device      )

										if mock_weights:
															# add 1 to weights to mock trained weights
															with torch.no_grad():
																				lora_attn_procs[name].to_q_lora.up.weight += 1
																				lora_attn_procs[name].to_k_lora.up.weight += 1
																				lora_attn_procs[name].to_v_lora.up.weight += 1
																				lora_attn_procs[name].to_out_lora.up.weight += 1

					return lora_attn_procs




@skip_mps
class 							__lowercase(							_UpperCamelCase    ,				_UpperCamelCase    ,				unittest.TestCase	):
						lowerCAmelCase_		:				int=							UNetaDConditionModel
						lowerCAmelCase_		:				Union[str, Any]=							"""sample"""






						@property
						def 		lowerCAmelCase (       self)      ->	List[Any]:




											"""simple docstring"""





											lowerCamelCase__					=4
											lowerCamelCase__					=4
											lowerCamelCase__					=4
											lowerCamelCase__					=(32, 32)

											lowerCamelCase__					=floats_tensor((batch_size, num_channels, num_frames) + sizes).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__					=torch.tensor([10]).to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__					=floats_tensor((batch_size, 4, 32)).to(_SCREAMING_SNAKE_CASE)

											return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}






						@property
						def 		lowerCAmelCase (       self)      ->	List[str]:




											"""simple docstring"""





											return (4, 4, 32, 32)






						@property
						def 		lowerCAmelCase (       self)      ->	Union[str, Any]:




											"""simple docstring"""





											return (4, 4, 32, 32)






						def 		lowerCAmelCase (       self)      ->	Tuple:




											"""simple docstring"""





											lowerCamelCase__					={
											    'block_out_channels': (32, 64),
											    'down_block_types': (
											        'CrossAttnDownBlock3D',
											        'DownBlock3D',
											    ),
											    'up_block_types': ('UpBlock3D', 'CrossAttnUpBlock3D'),
											    'cross_attention_dim': 32,
											    'attention_head_dim': 8,
											    'out_channels': 4,
											    'in_channels': 4,
											    'layers_per_block': 1,
											    'sample_size': 32,
											}
											lowerCamelCase__					=self.dummy_input
											return init_dict, inputs_dict






						@unittest.skipIf(
						    torch_device != 'cuda' or not is_xformers_available()     ,    reason='XFormers attention is only available with CUDA and `xformers` installed'     ,    )
						def 		lowerCAmelCase (       self)      ->	Any:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)

											model.enable_xformers_memory_efficient_attention()

											assert (
											    model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
											    == "XFormersAttnProcessor"
											), "xformers is not enabled"






						def 		lowerCAmelCase (       self)      ->	Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=32

											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()

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

																if isinstance(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE):
																					lowerCamelCase__					=output.sample

											self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__					=inputs_dict['sample'].shape
											self.assertEqual(output.shape     ,    _SCREAMING_SNAKE_CASE     ,    'Input and output shapes do not match')






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




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()

											with torch.no_grad():
																# Warmup pass when using mps (see #372)
																if torch_device == "mps" and isinstance(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE):
																					model(**self.dummy_input)

																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)
																if isinstance(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE):
																					lowerCamelCase__					=first.sample

																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)
																if isinstance(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE):
																					lowerCamelCase__					=second.sample

											lowerCamelCase__					=first.cpu().numpy()
											lowerCamelCase__					=second.cpu().numpy()
											lowerCamelCase__					=out_a[~np.isnan(_SCREAMING_SNAKE_CASE)]
											lowerCamelCase__					=out_a[~np.isnan(_SCREAMING_SNAKE_CASE)]
											lowerCamelCase__					=np.amax(np.abs(out_a - out_a))
											self.assertLessEqual(_SCREAMING_SNAKE_CASE     ,    1E-5)






						def 		lowerCAmelCase (       self)      ->	Dict:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()

											model.set_attention_slice('auto')
											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)
											assert output is not None

											model.set_attention_slice('max')
											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)
											assert output is not None

											model.set_attention_slice(2)
											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)
											assert output is not None






						def 		lowerCAmelCase (       self)      ->	Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE)

											# make sure we can set a list of attention processors
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											# test that attn processors can be set to itself
											model.set_attn_processor(model.attn_processors)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.0}).sample
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.5}).sample
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.5}).sample

											assert (samplea - samplea).abs().max() < 3E-3
											assert (samplea - samplea).abs().max() < 3E-3

											# sample 2 and sample 3 should be different
											assert (samplea - samplea).abs().max() > 3E-3






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




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											torch.manual_seed(0)
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE)
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.5}).sample

											with tempfile.TemporaryDirectory() as tmpdirname:
																model.save_attn_procs(_SCREAMING_SNAKE_CASE)
																self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,    'pytorch_lora_weights.bin')))
																torch.manual_seed(0)
																lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
																new_model.to(_SCREAMING_SNAKE_CASE)
																new_model.load_attn_procs(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=new_model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.5}).sample

											assert (sample - new_sample).abs().max() < 1E-3

											# LoRA and no LoRA should NOT be the same
											assert (sample - old_sample).abs().max() > 1E-4






						def 		lowerCAmelCase (       self)      ->	Any:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											torch.manual_seed(0)
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE)
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.5}).sample

											with tempfile.TemporaryDirectory() as tmpdirname:
																model.save_attn_procs(_SCREAMING_SNAKE_CASE     ,    safe_serialization=_SCREAMING_SNAKE_CASE)
																self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,    'pytorch_lora_weights.safetensors')))
																torch.manual_seed(0)
																lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
																new_model.to(_SCREAMING_SNAKE_CASE)
																new_model.load_attn_procs(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=new_model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.5}).sample

											assert (sample - new_sample).abs().max() < 3E-3

											# LoRA and no LoRA should NOT be the same
											assert (sample - old_sample).abs().max() > 1E-4






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




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											torch.manual_seed(0)
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE     ,    mock_weights=_SCREAMING_SNAKE_CASE)
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)
											# Saving as torch, properly reloads with directly filename
											with tempfile.TemporaryDirectory() as tmpdirname:
																model.save_attn_procs(_SCREAMING_SNAKE_CASE)
																self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,    'pytorch_lora_weights.bin')))
																torch.manual_seed(0)
																lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
																new_model.to(_SCREAMING_SNAKE_CASE)
																new_model.load_attn_procs(_SCREAMING_SNAKE_CASE     ,    weight_name='pytorch_lora_weights.bin')






						def 		lowerCAmelCase (       self)      ->	List[Any]:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											torch.manual_seed(0)
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE     ,    mock_weights=_SCREAMING_SNAKE_CASE)
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)
											# Saving as torch, properly reloads with directly filename
											with tempfile.TemporaryDirectory() as tmpdirname:
																model.save_attn_procs(_SCREAMING_SNAKE_CASE)
																self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,    'pytorch_lora_weights.bin')))
																torch.manual_seed(0)
																lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
																new_model.to(_SCREAMING_SNAKE_CASE)
																with self.assertRaises(_SCREAMING_SNAKE_CASE) as e:
																					new_model.load_attn_procs(_SCREAMING_SNAKE_CASE     ,    use_safetensors=_SCREAMING_SNAKE_CASE)
																self.assertIn('Error no file named pytorch_lora_weights.safetensors'     ,    str(e.exception))






						def 		lowerCAmelCase (       self)      ->	int:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=8

											torch.manual_seed(0)
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE)
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE     ,    cross_attention_kwargs={'scale': 0.0}).sample

											model.set_attn_processor(AttnProcessor())

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

											assert (sample - new_sample).abs().max() < 1E-4
											assert (sample - old_sample).abs().max() < 3E-3






						@unittest.skipIf(
						    torch_device != 'cuda' or not is_xformers_available()     ,    reason='XFormers attention is only available with CUDA and `xformers` installed'     ,    )
						def 		lowerCAmelCase (       self)      ->	Optional[Any]:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()

											lowerCamelCase__					=4

											torch.manual_seed(0)
											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__					=create_lora_layers(_SCREAMING_SNAKE_CASE)
											model.set_attn_processor(_SCREAMING_SNAKE_CASE)

											# default
											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

																model.enable_xformers_memory_efficient_attention()
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

																model.disable_xformers_memory_efficient_attention()
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE).sample

											assert (sample - on_sample).abs().max() < 1E-4
											assert (sample - off_sample).abs().max() < 1E-4






						def 		lowerCAmelCase (       self)      ->	List[Any]:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.prepare_init_args_and_inputs_for_common()
											lowerCamelCase__					=32

											lowerCamelCase__					=self.model_class(**_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()

											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)[0]

											model.enable_forward_chunking()
											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)[0]

											self.assertEqual(output.shape     ,    output_a.shape     ,    'Shape doesn\'t match')
											assert np.abs(output.cpu() - output_a.cpu()).max() < 1E-2


# (todo: sayakpaul) implement SLOW tests.







"""simple docstring"""



import random




class 							__lowercase:






						def __init__(       self     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE = 0.01     ,    _SCREAMING_SNAKE_CASE = 10_00     ,    _SCREAMING_SNAKE_CASE = -1     ,    )      ->	None:




											"""simple docstring"""





											lowerCamelCase__					=sample
											if len(self.sample) == 0:
																raise ValueError('Sample data can not be empty')
											lowerCamelCase__					=target
											if len(self.target) == 0:
																raise ValueError('Target data can not be empty')
											if len(self.sample) != len(self.target):
																raise ValueError('Sample data and Target data do not have matching lengths')
											lowerCamelCase__					=learning_rate
											lowerCamelCase__					=epoch_number
											lowerCamelCase__					=bias
											lowerCamelCase__					=len(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__					=len(sample[0])  # number of columns in dataset
											lowerCamelCase__					=[]






						def 		lowerCAmelCase (       self)      ->	None:




											"""simple docstring"""





											for sample in self.sample:
																sample.insert(0     ,    self.bias)

											for _ in range(self.col_sample):
																self.weight.append(random.random())

											self.weight.insert(0     ,    self.bias)

											lowerCamelCase__					=0

											while True:
																lowerCamelCase__					=False
																for i in range(self.number_sample):
																					lowerCamelCase__					=0
																					for j in range(self.col_sample + 1):
																										lowerCamelCase__					=u + self.weight[j] * self.sample[i][j]
																					lowerCamelCase__					=self.sign(_SCREAMING_SNAKE_CASE)
																					if y != self.target[i]:
																										for j in range(self.col_sample + 1):
																															lowerCamelCase__					=(
																															    self.weight[j]
																															    + self.learning_rate
																															    * (self.target[i] - y)
																															    * self.sample[i][j]
																															)
																										lowerCamelCase__					=True
            # print('Epoch: \n',epoch_count)
																lowerCamelCase__					=epoch_count + 1
																# if you want control the epoch or just by error
																if not has_misclassified:
																					print(('\nEpoch:\n', epoch_count))
																					print('------------------------\n')
																					# if epoch_count > self.epoch_number or not error:
																					break






						def 		lowerCAmelCase (       self     ,    _SCREAMING_SNAKE_CASE)      ->	None:




											"""simple docstring"""





											if len(self.sample) == 0:
																raise ValueError('Sample data can not be empty')
											sample.insert(0     ,    self.bias)
											lowerCamelCase__					=0
											for i in range(self.col_sample + 1):
																lowerCamelCase__					=u + self.weight[i] * sample[i]

											lowerCamelCase__					=self.sign(_SCREAMING_SNAKE_CASE)

											if y == -1:
																print(('Sample: ', sample))
																print('classification: P1')
											else:
																print(('Sample: ', sample))
																print('classification: P2')






						def 		lowerCAmelCase (       self     ,    _SCREAMING_SNAKE_CASE)      ->	int:




											"""simple docstring"""





											return 1 if u >= 0 else -1



_snake_case							:   int	  =       [
    [-0.6508, 0.1097, 4.0009],
    [-1.4492, 0.8896, 4.4005],
    [2.0850, 0.6876, 12.0710],
    [0.2626, 1.1476, 7.7985],
    [0.6418, 1.0234, 7.0427],
    [0.2569, 0.6730, 8.3265],
    [1.1155, 0.6043, 7.4446],
    [0.0914, 0.3399, 7.0677],
    [0.0121, 0.5256, 4.6316],
    [-0.0429, 0.4660, 5.4323],
    [0.4340, 0.6870, 8.2287],
    [0.2735, 1.0287, 7.1934],
    [0.4839, 0.4851, 7.4850],
    [0.4089, -0.1267, 5.5019],
    [1.4391, 0.1614, 8.5843],
    [-0.9115, -0.1973, 2.1962],
    [0.3654, 1.0475, 7.4858],
    [0.2144, 0.7515, 7.1699],
    [0.2013, 1.0014, 6.5489],
    [0.6483, 0.2183, 5.8991],
    [-0.1147, 0.2242, 7.2435],
    [-0.7970, 0.8795, 3.8762],
    [-1.0625, 0.6366, 2.4707],
    [0.5307, 0.1285, 5.6883],
    [-1.2200, 0.7777, 1.7252],
    [0.3957, 0.1076, 5.6623],
    [-0.1013, 0.5989, 7.1812],
    [2.4482, 0.9455, 11.2095],
    [2.0149, 0.6192, 10.9263],
    [0.2012, 0.2611, 5.4631],
]

_snake_case							:   List[str]	  =       [
    -1,
    -1,
    -1,
    1,
    1,
    -1,
    1,
    -1,
    1,
    1,
    -1,
    1,
    -1,
    -1,
    -1,
    -1,
    1,
    1,
    1,
    1,
    -1,
    1,
    1,
    1,
    1,
    -1,
    -1,
    1,
    -1,
    1,
]


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						_snake_case							:   int	  =       Perceptron(
						    sample=samples, target=target, learning_rate=0.01, epoch_number=1_000, bias=-1
						)
						network.training()
						print("Finished training perceptron")
						print("Enter values to predict or q to exit")
						while True:
												_snake_case							:   list	  =       []
												for i in range(len(samples[0])):
																		_snake_case							:   List[str]	  =       input("value: ").strip()
																		if user_input == "q":
																								break
																		_snake_case							:   Optional[Any]	  =       float(user_input)
																		sample.insert(i, observation)
												network.sort(sample)