





# Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets

def   __snake_case    (       _lowerCAmelCase			:			Dict						)			->    Optional[Any]:
   return 1 / (1 + np.exp(-z						))

def   __snake_case    (       _lowerCAmelCase			:			Any					,					_lowerCAmelCase			:			Any						)			->    List[Any]:
   return (-y * np.log(snake_case__						) - (1 - y) * np.log(1 - h						)).mean()

def   __snake_case    (       _lowerCAmelCase			:			Any					,					_lowerCAmelCase			:			Optional[int]					,					_lowerCAmelCase			:			List[Any]						)			->    Any:
   A_       :					List[str]        =      np.dot(snake_case__					,					snake_case__						)
   return np.sum(y * scores - np.log(1 + np.exp(snake_case__						)						)						)

def   __snake_case    (       _lowerCAmelCase			:			int					,					_lowerCAmelCase			:			Optional[int]					,					_lowerCAmelCase			:			List[str]					,					_lowerCAmelCase			:			List[Any]=70000						)			->    Tuple:
   A_       :					Dict        =      np.zeros(x.shape[1]						)

   for iterations in range(snake_case__						):
      A_       :					Optional[int]        =      np.dot(snake_case__					,					snake_case__						)
      A_       :					Any        =      sigmoid_function(snake_case__						)
      A_       :					List[str]        =      np.dot(x.T					,					h - y						) / y.size
      A_       :					Optional[int]        =      theta - alpha * gradient  # updating the weights
      A_       :					str        =      np.dot(snake_case__					,					snake_case__						)
      A_       :					str        =      sigmoid_function(snake_case__						)
      A_       :					Optional[int]        =      cost_function(snake_case__					,					snake_case__						)
      if iterations % 100 == 0:
         print(f"loss: {j} \t"						)  # printing the loss after every 100 iterations
   return theta


# In[68]:

if __name__ == "__main__":
 _lowerCAmelCase				:   List[Any]						       =						datasets.load_iris()
 _lowerCAmelCase				:   Optional[int]						       =						iris.data[:, :2]
 _lowerCAmelCase				:   int						       =						(iris.target != 0) * 1

 _lowerCAmelCase				:   Dict						       =						0.1
 _lowerCAmelCase				:   List[Any]						       =						logistic_reg(alpha, x, y, max_iterations=70_000)
 print('''theta: ''', theta)  # printing the theta i.e our weights vector

 def   __snake_case    (       _lowerCAmelCase			:			List[Any]						)			->    Dict:
    return sigmoid_function(
        np.dot(snake_case__					,					snake_case__						)						)  # predicting the value of probability from the logistic regression algorithm

 plt.figure(figsize=(10, 6))
 plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color='''b''', label='''0''')
 plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color='''r''', label='''1''')
 ((_lowerCAmelCase)       ,       (_lowerCAmelCase))				:   Dict						       =						(x[:, 0].min(), x[:, 0].max())
 ((_lowerCAmelCase)       ,       (_lowerCAmelCase))				:   Any						       =						(x[:, 1].min(), x[:, 1].max())
 ((_lowerCAmelCase)       ,       (_lowerCAmelCase))				:   Dict						       =						np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
 _lowerCAmelCase				:   List[Any]						       =						np.c_[xxa.ravel(), xxa.ravel()]
 _lowerCAmelCase				:   Optional[Any]						       =						predict_prob(grid).reshape(xxa.shape)
 plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors='''black''')

 plt.legend()





 plt.show()


from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__a         =   logging.get_logger(__name__)

__a         =   {
    'xlm-mlm-en-2048': 'https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json',
    'xlm-mlm-ende-1024': 'https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json',
    'xlm-mlm-enfr-1024': 'https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json',
    'xlm-mlm-enro-1024': 'https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json',
    'xlm-mlm-tlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json',
    'xlm-mlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json',
    'xlm-clm-enfr-1024': 'https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json',
    'xlm-clm-ende-1024': 'https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json',
    'xlm-mlm-17-1280': 'https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json',
    'xlm-mlm-100-1280': 'https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json',
}
class 					lowercase__(							UpperCAmelCase				):



	"""simple docstring"""




	a     :List[Any]       	=      'xlm'
	a     :Dict       	=      {
	    'hidden_size': 'emb_dim',
	    'num_attention_heads': 'n_heads',
	    'num_hidden_layers': 'n_layers',
	    'n_words': 'vocab_size',  # For backward compatibility
	}
	def __init__(			self    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Dict=3_0_1_4_5			,				SCREAMING_SNAKE_CASE_    :     Dict=2_0_4_8			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=1_2			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=1_6			,				SCREAMING_SNAKE_CASE_    :     Dict=0.1			,				SCREAMING_SNAKE_CASE_    :     str=0.1			,				SCREAMING_SNAKE_CASE_    :     Any=True			,				SCREAMING_SNAKE_CASE_    :     Any=False			,				SCREAMING_SNAKE_CASE_    :     str=False			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=False			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=1			,				SCREAMING_SNAKE_CASE_    :     Dict=True			,				SCREAMING_SNAKE_CASE_    :     Dict=5_1_2			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=2_0_4_8**-0.5			,				SCREAMING_SNAKE_CASE_    :     Dict=1e-12			,				SCREAMING_SNAKE_CASE_    :     Any=0.02			,				SCREAMING_SNAKE_CASE_    :     str=0			,				SCREAMING_SNAKE_CASE_    :     List[Any]=1			,				SCREAMING_SNAKE_CASE_    :     List[Any]=2			,				SCREAMING_SNAKE_CASE_    :     int=3			,				SCREAMING_SNAKE_CASE_    :     Dict=5			,				SCREAMING_SNAKE_CASE_    :     int=True			,				SCREAMING_SNAKE_CASE_    :     List[Any]="first"			,				SCREAMING_SNAKE_CASE_    :     Any=True			,				SCREAMING_SNAKE_CASE_    :     List[Any]=None			,				SCREAMING_SNAKE_CASE_    :     str=True			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]=0.1			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=5			,				SCREAMING_SNAKE_CASE_    :     List[str]=5			,				SCREAMING_SNAKE_CASE_    :     Any=0			,				SCREAMING_SNAKE_CASE_    :     str=0			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=2			,				SCREAMING_SNAKE_CASE_    :     Tuple=0			,				**SCREAMING_SNAKE_CASE_    :     Dict			,				)			->	List[Any]:
					lowercase_	    =   vocab_size
					lowercase_	    =   emb_dim
					lowercase_	    =   n_layers
					lowercase_	    =   n_heads
					lowercase_	    =   dropout
					lowercase_	    =   attention_dropout
					lowercase_	    =   gelu_activation
					lowercase_	    =   sinusoidal_embeddings
					lowercase_	    =   causal
					lowercase_	    =   asm
					lowercase_	    =   n_langs
					lowercase_	    =   use_lang_emb
					lowercase_	    =   layer_norm_eps
					lowercase_	    =   bos_index
					lowercase_	    =   eos_index
					lowercase_	    =   pad_index
					lowercase_	    =   unk_index
					lowercase_	    =   mask_index
					lowercase_	    =   is_encoder
					lowercase_	    =   max_position_embeddings
					lowercase_	    =   embed_init_std
					lowercase_	    =   init_std
					lowercase_	    =   summary_type
					lowercase_	    =   summary_use_proj
					lowercase_	    =   summary_activation
					lowercase_	    =   summary_proj_to_labels
					lowercase_	    =   summary_first_dropout
					lowercase_	    =   start_n_top
					lowercase_	    =   end_n_top
					lowercase_	    =   mask_token_id
					lowercase_	    =   lang_id

					if "n_words" in kwargs:
									lowercase_	    =   kwargs['''n_words''']

					super().__init__(pad_token_id=SCREAMING_SNAKE_CASE_			,				bos_token_id=SCREAMING_SNAKE_CASE_			,				**SCREAMING_SNAKE_CASE_			)

class 					lowercase__(							UpperCAmelCase				):



	"""simple docstring"""




	@property
	def 		_lowercase    (			self    :     int			)			->	Mapping[str, Mapping[int, str]]:
					if self.task == "multiple-choice":
									lowercase_	    =   {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
					else:
									lowercase_	    =   {0: '''batch''', 1: '''sequence'''}
					return OrderedDict(
					    [
					        ('''input_ids''', dynamic_axis),
					        ('''attention_mask''', dynamic_axis),
					        ('''token_type_ids''', dynamic_axis),
					    ]			)




