# 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							:   List[str]	):
		"""simple docstring"""







		return 1 / (1 + np.exp(-z	))




def       _snake_case	(   lowerCAmelCase							:   List[Any]   , lowerCAmelCase							:   Dict	):
		"""simple docstring"""







		return (-y * np.log(lowerCAmelCase	) - (1 - y) * np.log(1 - h	)).mean()




def       _snake_case	(   lowerCAmelCase							:   Union[str, Any]   , lowerCAmelCase							:   Any   , lowerCAmelCase							:   str	):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    np.dot(lowerCAmelCase   , lowerCAmelCase	)
		return np.sum(y * scores - np.log(1 + np.exp(lowerCAmelCase	)	)	)




def       _snake_case	(   lowerCAmelCase							:   List[str]   , lowerCAmelCase							:   str   , lowerCAmelCase							:   Tuple   , lowerCAmelCase							:   Dict=7_0_0_0_0	):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    np.zeros(x.shape[1]	)

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


# In[68]:

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

		__lowerCamelCase					:	Tuple       =  0.1
		__lowerCamelCase					:	str       =  logistic_reg(alpha, x, y, max_iterations=7_00_00)
		print('''theta: ''', theta)  # printing the theta i.e our weights vector




		def       _snake_case	(   lowerCAmelCase							:   Any	):
				"""simple docstring"""







				return sigmoid_function(
				    np.dot(lowerCAmelCase   , lowerCAmelCase	)	)  # 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))					:	List[Any]       =  (x[:, 0].min(), x[:, 0].max())
		((__lowerCamelCase)   ,						(__lowerCamelCase))					:	Any       =  (x[:, 1].min(), x[:, 1].max())
		((__lowerCamelCase)   ,						(__lowerCamelCase))					:	Optional[Any]       =  np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
		__lowerCamelCase					:	Optional[int]       =  np.c_[xxa.ravel(), xxa.ravel()]
		__lowerCamelCase					:	Union[str, Any]       =  predict_prob(grid).reshape(xxa.shape)
		plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors='''black''')

		plt.legend()







		plt.show()

import json
from typing import List, Optional, Tuple

from tokenizers import normalizers
from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roformer import RoFormerTokenizer
from .tokenization_utils import JiebaPreTokenizer


__lowerCamelCase					:	Optional[Any]       =  logging.get_logger(__name__)

__lowerCamelCase					:	Dict       =  {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

__lowerCamelCase					:	int       =  {
    '''vocab_file''': {
        '''junnyu/roformer_chinese_small''': '''https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt''',
        '''junnyu/roformer_chinese_base''': '''https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt''',
        '''junnyu/roformer_chinese_char_small''': (
            '''https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt'''
        ),
        '''junnyu/roformer_chinese_char_base''': (
            '''https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt'''
        ),
        '''junnyu/roformer_small_discriminator''': (
            '''https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt'''
        ),
        '''junnyu/roformer_small_generator''': (
            '''https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt'''
        ),
    }
}

__lowerCamelCase					:	Any       =  {
    '''junnyu/roformer_chinese_small''': 15_36,
    '''junnyu/roformer_chinese_base''': 15_36,
    '''junnyu/roformer_chinese_char_small''': 5_12,
    '''junnyu/roformer_chinese_char_base''': 5_12,
    '''junnyu/roformer_small_discriminator''': 1_28,
    '''junnyu/roformer_small_generator''': 1_28,
}


__lowerCamelCase					:	Union[str, Any]       =  {
    '''junnyu/roformer_chinese_small''': {'''do_lower_case''': True},
    '''junnyu/roformer_chinese_base''': {'''do_lower_case''': True},
    '''junnyu/roformer_chinese_char_small''': {'''do_lower_case''': True},
    '''junnyu/roformer_chinese_char_base''': {'''do_lower_case''': True},
    '''junnyu/roformer_small_discriminator''': {'''do_lower_case''': True},
    '''junnyu/roformer_small_generator''': {'''do_lower_case''': True},
}






class 		a__						(					A__					):
					A	       =							VOCAB_FILES_NAMES
					A	       =							PRETRAINED_VOCAB_FILES_MAP
					A	       =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					A	       =							PRETRAINED_INIT_CONFIGURATION
					A	       =							RoFormerTokenizer

					def __init__(    self      :       List[str],_A      :       int=None,_A      :       int=None,_A      :       int=True,_A      :       List[Any]="[UNK]",_A      :       Tuple="[SEP]",_A      :       List[Any]="[PAD]",_A      :       Optional[int]="[CLS]",_A      :       Optional[Any]="[MASK]",_A      :       Optional[int]=True,_A      :       List[str]=None,**_A      :       List[Any],):







							"""simple docstring"""






							super().__init__(
							    _A,tokenizer_file=_A,do_lower_case=_A,unk_token=_A,sep_token=_A,pad_token=_A,cls_token=_A,mask_token=_A,tokenize_chinese_chars=_A,strip_accents=_A,**_A,)

							SCREAMING_SNAKE_CASE_  :		Tuple				      =    json.loads(self.backend_tokenizer.normalizer.__getstate__()    )
							if (
							    pre_tok_state.get("lowercase",_A    ) != do_lower_case
							    or pre_tok_state.get("strip_accents",_A    ) != strip_accents
							):
									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    getattr(_A,pre_tok_state.pop("type"    )    )
									SCREAMING_SNAKE_CASE_  :		Any				      =    do_lower_case
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    strip_accents
									SCREAMING_SNAKE_CASE_  :		str				      =    pre_tok_class(**_A    )

							SCREAMING_SNAKE_CASE_  :		List[str]				      =    do_lower_case

					def __getstate__(    self      :       Optional[int]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict				      =    self.__dict__.copy()
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    BertPreTokenizer()
							return state

					def __setstate__(    self      :       List[Any],_A      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    d
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    self.__dict__["_tokenizer"].get_vocab()
							SCREAMING_SNAKE_CASE_  :		Any				      =    PreTokenizer.custom(JiebaPreTokenizer(_A    )    )

					def 				__UpperCamelCase   (    self      :       Union[str, Any],_A      :       List[Any],_A      :       str=None    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    [self.cls_token_id] + token_ids_a + [self.sep_token_id]

							if token_ids_a:
									output += token_ids_a + [self.sep_token_id]

							return output

					def 				__UpperCamelCase   (    self      :       str,_A      :       List[int],_A      :       Optional[List[int]] = None    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    [self.sep_token_id]
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    [self.cls_token_id]
							if token_ids_a is None:
									return len(cls + token_ids_a + sep    ) * [0]
							return len(cls + token_ids_a + sep    ) * [0] + len(token_ids_a + sep    ) * [1]

					def 				__UpperCamelCase   (    self      :       int,_A      :       str,_A      :       Optional[str] = None    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    self._tokenizer.model.save(_A,name=_A    )
							return tuple(_A    )






					def 				__UpperCamelCase   (    self      :       int,_A      :       Optional[int],_A      :       List[Any]=None,_A      :       Tuple=None,_A      :       str=False,**_A      :       List[Any],):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    BertPreTokenizer()
							return super().save_pretrained(_A,_A,_A,_A,**_A    )
