

# 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     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     return 1 / (1 + np.exp(-z    ))
def     UpperCAmelCase_       (						_A				,		_A    ):





     '''simple docstring'''




     return (-y * np.log(_A    ) - (1 - y) * np.log(1 - h    )).mean()
def     UpperCAmelCase_       (						_A				,		_A				,		_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   np.dot(_A				,		_A    )
     return np.sum(y * scores - np.log(1 + np.exp(_A    )    )    )
def     UpperCAmelCase_       (						_A				,		_A				,		_A				,		_A=7_00_00    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   np.zeros(x.shape[1]    )

     for iterations in range(_A    ):
          SCREAMING_SNAKE_CASE__   =   np.dot(_A				,		_A    )
          SCREAMING_SNAKE_CASE__   =   sigmoid_function(_A    )
          SCREAMING_SNAKE_CASE__   =   np.dot(x.T				,		h - y    ) / y.size
          SCREAMING_SNAKE_CASE__   =   theta - alpha * gradient  # updating the weights
          SCREAMING_SNAKE_CASE__   =   np.dot(_A				,		_A    )
          SCREAMING_SNAKE_CASE__   =   sigmoid_function(_A    )
          SCREAMING_SNAKE_CASE__   =   cost_function(_A				,		_A    )
          if iterations % 1_00 == 0:
               print(F'''loss: {j} \t'''    )  # printing the loss after every 100 iterations
     return theta


# In[68]:

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

       _SCREAMING_SNAKE_CASE					:  List[str]             =      0.1
       _SCREAMING_SNAKE_CASE					:  Optional[int]             =      logistic_reg(alpha, x, y, max_iterations=70000)
       print('''theta: ''', theta)  # printing the theta i.e our weights vector
       def     UpperCAmelCase_       (						_A    ):





            '''simple docstring'''




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

       plt.legend()







       plt.show()





import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


_SCREAMING_SNAKE_CASE					:  List[str]             =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:  Tuple             =      OrderedDict(
    [
        ('''align''', '''EfficientNetImageProcessor'''),
        ('''beit''', '''BeitImageProcessor'''),
        ('''bit''', '''BitImageProcessor'''),
        ('''blip''', '''BlipImageProcessor'''),
        ('''blip-2''', '''BlipImageProcessor'''),
        ('''bridgetower''', '''BridgeTowerImageProcessor'''),
        ('''chinese_clip''', '''ChineseCLIPImageProcessor'''),
        ('''clip''', '''CLIPImageProcessor'''),
        ('''clipseg''', '''ViTImageProcessor'''),
        ('''conditional_detr''', '''ConditionalDetrImageProcessor'''),
        ('''convnext''', '''ConvNextImageProcessor'''),
        ('''convnextv2''', '''ConvNextImageProcessor'''),
        ('''cvt''', '''ConvNextImageProcessor'''),
        ('''data2vec-vision''', '''BeitImageProcessor'''),
        ('''deformable_detr''', '''DeformableDetrImageProcessor'''),
        ('''deit''', '''DeiTImageProcessor'''),
        ('''deta''', '''DetaImageProcessor'''),
        ('''detr''', '''DetrImageProcessor'''),
        ('''dinat''', '''ViTImageProcessor'''),
        ('''donut-swin''', '''DonutImageProcessor'''),
        ('''dpt''', '''DPTImageProcessor'''),
        ('''efficientformer''', '''EfficientFormerImageProcessor'''),
        ('''efficientnet''', '''EfficientNetImageProcessor'''),
        ('''flava''', '''FlavaImageProcessor'''),
        ('''focalnet''', '''BitImageProcessor'''),
        ('''git''', '''CLIPImageProcessor'''),
        ('''glpn''', '''GLPNImageProcessor'''),
        ('''groupvit''', '''CLIPImageProcessor'''),
        ('''imagegpt''', '''ImageGPTImageProcessor'''),
        ('''instructblip''', '''BlipImageProcessor'''),
        ('''layoutlmv2''', '''LayoutLMv2ImageProcessor'''),
        ('''layoutlmv3''', '''LayoutLMv3ImageProcessor'''),
        ('''levit''', '''LevitImageProcessor'''),
        ('''mask2former''', '''Mask2FormerImageProcessor'''),
        ('''maskformer''', '''MaskFormerImageProcessor'''),
        ('''mgp-str''', '''ViTImageProcessor'''),
        ('''mobilenet_v1''', '''MobileNetV1ImageProcessor'''),
        ('''mobilenet_v2''', '''MobileNetV2ImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevitv2''', '''MobileViTImageProcessor'''),
        ('''nat''', '''ViTImageProcessor'''),
        ('''oneformer''', '''OneFormerImageProcessor'''),
        ('''owlvit''', '''OwlViTImageProcessor'''),
        ('''perceiver''', '''PerceiverImageProcessor'''),
        ('''pix2struct''', '''Pix2StructImageProcessor'''),
        ('''poolformer''', '''PoolFormerImageProcessor'''),
        ('''regnet''', '''ConvNextImageProcessor'''),
        ('''resnet''', '''ConvNextImageProcessor'''),
        ('''sam''', '''SamImageProcessor'''),
        ('''segformer''', '''SegformerImageProcessor'''),
        ('''swiftformer''', '''ViTImageProcessor'''),
        ('''swin''', '''ViTImageProcessor'''),
        ('''swin2sr''', '''Swin2SRImageProcessor'''),
        ('''swinv2''', '''ViTImageProcessor'''),
        ('''table-transformer''', '''DetrImageProcessor'''),
        ('''timesformer''', '''VideoMAEImageProcessor'''),
        ('''tvlt''', '''TvltImageProcessor'''),
        ('''upernet''', '''SegformerImageProcessor'''),
        ('''van''', '''ConvNextImageProcessor'''),
        ('''videomae''', '''VideoMAEImageProcessor'''),
        ('''vilt''', '''ViltImageProcessor'''),
        ('''vit''', '''ViTImageProcessor'''),
        ('''vit_hybrid''', '''ViTHybridImageProcessor'''),
        ('''vit_mae''', '''ViTImageProcessor'''),
        ('''vit_msn''', '''ViTImageProcessor'''),
        ('''xclip''', '''CLIPImageProcessor'''),
        ('''yolos''', '''YolosImageProcessor'''),
    ]
)

_SCREAMING_SNAKE_CASE					:  str             =      _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
          if class_name in extractors:
               SCREAMING_SNAKE_CASE__   =   model_type_to_module_name(_A    )

               SCREAMING_SNAKE_CASE__   =   importlib.import_module(F'''.{module_name}'''				,		'''transformers.models'''    )
               try:
                    return getattr(_A				,		_A    )
               except AttributeError:
                    continue

     for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
          if getattr(_A				,		'''__name__'''				,		_A    ) == class_name:
               return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
     SCREAMING_SNAKE_CASE__   =   importlib.import_module('''transformers'''    )
     if hasattr(_A				,		_A    ):
          return getattr(_A				,		_A    )

     return None
def     UpperCAmelCase_       (						_A				,		_A = None				,		_A = False				,		_A = False				,		_A = None				,		_A = None				,		_A = None				,		_A = False				,		**_A				,		):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   get_file_from_repo(
         _A				,		_A				,		cache_dir=_A				,		force_download=_A				,		resume_download=_A				,		proxies=_A				,		use_auth_token=_A				,		revision=_A				,		local_files_only=_A				,		)
     if resolved_config_file is None:
          logger.info(
              '''Could not locate the image processor configuration file, will try to use the model config instead.'''    )
          return {}

     with open(_A				,		encoding='''utf-8'''    ) as reader:
          return json.load(_A    )







class 	UpperCAmelCase__		:






  """simple docstring"""


  def __init__(							self						:		List[Any] )		->							int:
       raise EnvironmentError(
           '''AutoImageProcessor is designed to be instantiated '''
           '''using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.''' )






  @classmethod
  @replace_list_option_in_docstrings(__lowerCamelCase )
  def 				lowercase_		(							cls						:		Optional[int]     ,       __lowerCamelCase						:		Any     ,       **__lowerCamelCase						:		Tuple )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   kwargs.pop('''config'''     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   kwargs.pop('''trust_remote_code'''     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   True

       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   ImageProcessingMixin.get_image_processor_dict(__lowerCamelCase     ,       **__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   config_dict.get('''image_processor_type'''     ,       __lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   None
       if "AutoImageProcessor" in config_dict.get('''auto_map'''     ,       {} ):
            SCREAMING_SNAKE_CASE__   =   config_dict['''auto_map''']['''AutoImageProcessor''']

       # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
       # and if so, infer the image processor class from there.
       if image_processor_class is None and image_processor_auto_map is None:
            SCREAMING_SNAKE_CASE__   =   config_dict.pop('''feature_extractor_type'''     ,       __lowerCamelCase )
            if feature_extractor_class is not None:
                 logger.warning(
                     '''Could not find image processor class in the image processor config or the model config. Loading'''
                     ''' based on pattern matching with the model\'s feature extractor configuration.''' )
                 SCREAMING_SNAKE_CASE__   =   feature_extractor_class.replace('''FeatureExtractor'''     ,       '''ImageProcessor''' )
            if "AutoFeatureExtractor" in config_dict.get('''auto_map'''     ,       {} ):
                 SCREAMING_SNAKE_CASE__   =   config_dict['''auto_map''']['''AutoFeatureExtractor''']
                 SCREAMING_SNAKE_CASE__   =   feature_extractor_auto_map.replace('''FeatureExtractor'''     ,       '''ImageProcessor''' )
                 logger.warning(
                     '''Could not find image processor auto map in the image processor config or the model config.'''
                     ''' Loading based on pattern matching with the model\'s feature extractor configuration.''' )

        # If we don't find the image processor class in the image processor config, let's try the model config.
       if image_processor_class is None and image_processor_auto_map is None:
            if not isinstance(__lowerCamelCase     ,       __lowerCamelCase ):
                 SCREAMING_SNAKE_CASE__   =   AutoConfig.from_pretrained(__lowerCamelCase     ,       **__lowerCamelCase )
            # It could be in `config.image_processor_type``
            SCREAMING_SNAKE_CASE__   =   getattr(__lowerCamelCase     ,       '''image_processor_type'''     ,       __lowerCamelCase )
            if hasattr(__lowerCamelCase     ,       '''auto_map''' ) and "AutoImageProcessor" in config.auto_map:
                 SCREAMING_SNAKE_CASE__   =   config.auto_map['''AutoImageProcessor''']

       if image_processor_class is not None:
            SCREAMING_SNAKE_CASE__   =   image_processor_class_from_name(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   image_processor_auto_map is not None
       SCREAMING_SNAKE_CASE__   =   image_processor_class is not None or type(__lowerCamelCase ) in IMAGE_PROCESSOR_MAPPING
       SCREAMING_SNAKE_CASE__   =   resolve_trust_remote_code(
           __lowerCamelCase     ,       __lowerCamelCase     ,       __lowerCamelCase     ,       __lowerCamelCase )

       if has_remote_code and trust_remote_code:
            SCREAMING_SNAKE_CASE__   =   get_class_from_dynamic_module(
                __lowerCamelCase     ,       __lowerCamelCase     ,       **__lowerCamelCase )
            SCREAMING_SNAKE_CASE__   =   kwargs.pop('''code_revision'''     ,       __lowerCamelCase )
            if os.path.isdir(__lowerCamelCase ):
                 image_processor_class.register_for_auto_class()
            return image_processor_class.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )
       elif image_processor_class is not None:
            return image_processor_class.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )
       # Last try: we use the IMAGE_PROCESSOR_MAPPING.
       elif type(__lowerCamelCase ) in IMAGE_PROCESSOR_MAPPING:
            SCREAMING_SNAKE_CASE__   =   IMAGE_PROCESSOR_MAPPING[type(__lowerCamelCase )]
            return image_processor_class.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )

       raise ValueError(
           f'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '''
           f'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '''
           f'''`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}''' )







  @staticmethod
  def 				lowercase_		(							__lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		Optional[int] )		->							str:
       IMAGE_PROCESSOR_MAPPING.register(__lowerCamelCase     ,       __lowerCamelCase )


