



# 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     (       snake_case__	:   List[Any]     )     ->					List[Any]:
   return 1 / (1 + np.exp(-z     ))
def 		UpperCamelCase     (       snake_case__	:   List[str]	,					snake_case__	:   Optional[Any]     )     ->					Optional[int]:
   return (-y * np.log(snake_case__     ) - (1 - y) * np.log(1 - h     )).mean()
def 		UpperCamelCase     (       snake_case__	:   int	,					snake_case__	:   List[str]	,					snake_case__	:   Any     )     ->					List[str]:
   UpperCamelCase   :  Optional[Any]						     =     np.dot(snake_case__	,					snake_case__     )
   return np.sum(y * scores - np.log(1 + np.exp(snake_case__     )     )     )
def 		UpperCamelCase     (       snake_case__	:   Any	,					snake_case__	:   Union[str, Any]	,					snake_case__	:   Any	,					snake_case__	:   int=70000     )     ->					Tuple:
   UpperCamelCase   :  Dict						     =     np.zeros(x.shape[1]     )

   for iterations in range(snake_case__     ):
      UpperCamelCase   :  Optional[Any]						     =     np.dot(snake_case__	,					snake_case__     )
      UpperCamelCase   :  int						     =     sigmoid_function(snake_case__     )
      UpperCamelCase   :  str						     =     np.dot(x.T	,					h - y     ) / y.size
      UpperCamelCase   :  Optional[Any]						     =     theta - alpha * gradient  # updating the weights
      UpperCamelCase   :  List[Any]						     =     np.dot(snake_case__	,					snake_case__     )
      UpperCamelCase   :  Tuple						     =     sigmoid_function(snake_case__     )
      UpperCamelCase   :  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__":
    __UpperCAmelCase	       =	datasets.load_iris()
    __UpperCAmelCase	       =	iris.data[:, :2]
    __UpperCAmelCase	       =	(iris.target != 0) * 1

    __UpperCAmelCase	       =	0.1
    __UpperCAmelCase	       =	logistic_reg(alpha, x, y, max_iterations=70_000)
    print('''theta: ''', theta)  # printing the theta i.e our weights vector
    def 		UpperCamelCase     (       snake_case__	:   List[Any]     )     ->					Union[str, Any]:
       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''')
    ((__UpperCAmelCase)       ,  (__UpperCAmelCase))	       =	(x[:, 0].min(), x[:, 0].max())
    ((__UpperCAmelCase)       ,  (__UpperCAmelCase))	       =	(x[:, 1].min(), x[:, 1].max())
    ((__UpperCAmelCase)       ,  (__UpperCAmelCase))	       =	np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
    __UpperCAmelCase	       =	np.c_[xxa.ravel(), xxa.ravel()]
    __UpperCAmelCase	       =	predict_prob(grid).reshape(xxa.shape)
    plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors='''black''')

    plt.legend()


    plt.show()








import argparse

import torch
from safetensors.torch import load_file

from diffusers import StableDiffusionPipeline
def 		UpperCamelCase     (       snake_case__	:   List[Any]	,					snake_case__	:   Union[str, Any]	,					snake_case__	:   Tuple	,					snake_case__	:   Union[str, Any]	,					snake_case__	:   List[Any]     )     ->					Tuple:
   # load base model
   UpperCamelCase   :  Tuple						     =     StableDiffusionPipeline.from_pretrained(snake_case__	,					torch_dtype=torch.floataa     )

   # load LoRA weight from .safetensors
   UpperCamelCase   :  Union[str, Any]						     =     load_file(snake_case__     )

   UpperCamelCase   :  int						     =     []

   # directly update weight in diffusers model
   for key in state_dict:
      # it is suggested to print out the key, it usually will be something like below
      # "lora_te_text_model_encoder_layers_0_self_attn_k_proj.lora_down.weight"

      # as we have set the alpha beforehand, so just skip
      if ".alpha" in key or key in visited:
         continue

      if "text" in key:
         UpperCamelCase   :  Optional[Any]						     =     key.split('.'     )[0].split(LORA_PREFIX_TEXT_ENCODER + '_'     )[-1].split('_'     )
         UpperCamelCase   :  Optional[Any]						     =     pipeline.text_encoder
      else:
         UpperCamelCase   :  Tuple						     =     key.split('.'     )[0].split(LORA_PREFIX_UNET + '_'     )[-1].split('_'     )
         UpperCamelCase   :  List[str]						     =     pipeline.unet

      # find the target layer
      UpperCamelCase   :  Optional[Any]						     =     layer_infos.pop(0     )
      while len(snake_case__     ) > -1:
         try:
            UpperCamelCase   :  Dict						     =     curr_layer.__getattr__(snake_case__     )
            if len(snake_case__     ) > 0:
               UpperCamelCase   :  Dict						     =     layer_infos.pop(0     )
            elif len(snake_case__     ) == 0:
               break
         except Exception:
            if len(snake_case__     ) > 0:
               temp_name += "_" + layer_infos.pop(0     )
            else:
               UpperCamelCase   :  Tuple						     =     layer_infos.pop(0     )

      UpperCamelCase   :  List[Any]						     =     []
      if "lora_down" in key:
         pair_keys.append(key.replace('lora_down'	,					'lora_up'     )     )
         pair_keys.append(snake_case__     )
      else:
         pair_keys.append(snake_case__     )
         pair_keys.append(key.replace('lora_up'	,					'lora_down'     )     )

      # update weight
      if len(state_dict[pair_keys[0]].shape     ) == 4:
         UpperCamelCase   :  Dict						     =     state_dict[pair_keys[0]].squeeze(3     ).squeeze(2     ).to(torch.floataa     )
         UpperCamelCase   :  Union[str, Any]						     =     state_dict[pair_keys[1]].squeeze(3     ).squeeze(2     ).to(torch.floataa     )
         curr_layer.weight.data += alpha * torch.mm(snake_case__	,					snake_case__     ).unsqueeze(2     ).unsqueeze(3     )
      else:
         UpperCamelCase   :  Dict						     =     state_dict[pair_keys[0]].to(torch.floataa     )
         UpperCamelCase   :  List[Any]						     =     state_dict[pair_keys[1]].to(torch.floataa     )
         curr_layer.weight.data += alpha * torch.mm(snake_case__	,					snake_case__     )

      # update visited list
      for item in pair_keys:
         visited.append(snake_case__     )

   return pipeline


if __name__ == "__main__":
    __UpperCAmelCase	       =	argparse.ArgumentParser()

    parser.add_argument(
        '''--base_model_path''', default=None, type=str, required=True, help='''Path to the base model in diffusers format.'''
    )
    parser.add_argument(
        '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
    )
    parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
    parser.add_argument(
        '''--lora_prefix_unet''', default='''lora_unet''', type=str, help='''The prefix of UNet weight in safetensors'''
    )
    parser.add_argument(
        '''--lora_prefix_text_encoder''',
        default='''lora_te''',
        type=str,
        help='''The prefix of text encoder weight in safetensors''',
    )
    parser.add_argument('''--alpha''', default=0.75, type=float, help='''The merging ratio in W = W0 + alpha * deltaW''')
    parser.add_argument(
        '''--to_safetensors''', action='''store_true''', help='''Whether to store pipeline in safetensors format or not.'''
    )
    parser.add_argument('''--device''', type=str, help='''Device to use (e.g. cpu, cuda:0, cuda:1, etc.)''')

    __UpperCAmelCase	       =	parser.parse_args()

    __UpperCAmelCase	       =	args.base_model_path
    __UpperCAmelCase	       =	args.checkpoint_path
    __UpperCAmelCase	       =	args.dump_path
    __UpperCAmelCase	       =	args.lora_prefix_unet
    __UpperCAmelCase	       =	args.lora_prefix_text_encoder
    __UpperCAmelCase	       =	args.alpha

    __UpperCAmelCase	       =	convert(base_model_path, checkpoint_path, lora_prefix_unet, lora_prefix_text_encoder, alpha)

    __UpperCAmelCase	       =	pipe.to(args.device)
    pipe.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)



