python3.11 -m pip install ultralytics

  ex : docker exec -it test-mysql bash

  example : docker run -e MYSQL_ROOT_PASSWORD=your_password -p 3306:3306 mysql:8.0

1) sudo docker pull dockerhub/name:latest
2) sudo docker run -d --name container-name -e AWS_ACCESS_KEY_ID=access_key_id -e AWS_SECRET_ACCESS_KEY=access_key -e AWS_DEFAULT_REGION=ap-south-1 -p 8001:8001 dockerhub/name

For ec2 instance removing and new container:
stop the container : sudo docker stop count-web-application-container
remove the docker : sudo docker rm count-web-application-container
Check the id of image : sudo docker images
remove the image : sudo docker rmi 0d051dca991e(id of the image)

    #Use the official Python image
    FROM python:3.11.5
    
    # Install necessary system dependencies including libgl1-mesa-glx
    RUN apt-get update && apt-get install -y libgl1-mesa-glx
    
    # Set the working directory in the container
    WORKDIR /app
    
    # Copy the dependencies file to the working directory
    COPY requirements.txt .
    
    # Install REQUIREMENTS
    RUN pip install --upgrade pip && \
      pip install -r requirements.txt && \
      pip uninstall -y fastapi && \
      pip install fastapi==0.97.0 && \
      pip uninstall -y fastapi-users && \
      pip install fastapi-users==12.1.2 && \
      pip uninstall -y fastapi-users-db-beanie && \
      pip install fastapi-users-db-beanie==3.0.0 && \
      pip uninstall -y fastapi-users-db-mongodb && \
      pip install fastapi-users-db-mongodb==1.1.0 && \
      pip uninstall -y jwt PyJWT && \
      pip install PyJWT && \
      pip uninstall -y motor &&\
      pip install motor==3.4.0
        
    
    # Copy the content of the local src directory to the working directory
    COPY . /app
    
    # Command to run the FastAPI application with Uvicorn
    CMD ["uvicorn","api1:app","--host","0.0.0.0","--port","8001"]

 class Amar:
    amar ="amar"
    
    def __init__(self,a,b):
        self.a = a
        self.b = b
    
    @staticmethod
    def Amar_call():
        return amar
    
    @classmethod
    def Amar_call1(cls):
        return cls.amar


amar = Amar(1,2)
print(amar.amar)
print(amar.a)

# classs level
print(amar.Amar_call1())
print(Amar.Amar_call1())

# Static level
print(amar.Amar_call().amar) # it's returning Amar_class as a object
print(Amar.Amar_call().amar) # it's returning Amar_class as a object

  a) The basic behind idea behind yolo is to divide the i/p image into a grid of cellsand , for each cell, predict the probabilities of the presence of object and bounding box coordinates of the object.

  Inputting an image: The image is resized to 448x448, then passed through a CNN to extract features

  Dividing the image into a grid: The grid size can be 13x13 or 19x19, with each cell containing 5 boxes

  Predicting bounding boxes and class probabilities: Each cell predicts a set of bounding boxes and class probabilities

  Removing overlapping guesses: YOLO uses non-maximum suppression to remove any guesses that overlap with other guesses

  Outputting the remaining guesses: YOLO outputs the remaining guesses as rectangles and object labels

 Gaussian filter: This filter applies a two-dimensional Gaussian function to the neighborhood pixels to smoothen the image. The greater the standard deviation of the Gaussian distribution, the greater the blur will be.

 Median filter: This filter replaces each pixel value with the median of the neighboring pixels. It is effective in reducing the salt and pepper noise from the images.

 Laplacian filter: This filter convolves over the image based on the principle of the Laplace transform. It calculates the image matrix's second-order derivative and highlights its edges and details by emphasizing regions of rapid intensity changes.

1) Sobel filter: It detects the edges by calculating the horizontal and vertical derivatives of the image and then combining them.

     	Sobel function in opencv is used to perform edge detection on an image. it computes the gradient of the image intensity at each pixel, which can be used to detect edges or sharp changes in intensity. Sobel edge detection typically involves convolving the image with a Sobel kernel in the both the horizontal and vertical directions to compute the gradient magnitude and direction.

 	2) Robert filter: It detects the edges by calculating and combining derivatives of both the image diagonals.

  Binary threshold filter: This filter converts a greyscaled image into a binary image by setting pixel values above a threshold to white and values below the threshold to black.

  Adaptive threshold filter: It is similar to the binary threshold filter, but it determines its threshold based on the local neighborhood of each pixel.

  Dilation filter: This filter expands the boundaries of regions in an image by replacing each pixel with a maximum value in its neighborhood. It helps fill gaps, join broken lines, and enlarge objects.

  Erosion filter: This filter shrinks the boundaries of regions by replacing each pixel with the minimum value with its neighborhood. It helps remove noise, separates connected objects, and reduces object size.

Efficient Hybrid Encoder: Baidu's RT-DETR uses an efficient hybrid encoder that processes multiscale features by decoupling intra-scale interaction and cross-scale fusion. This unique Vision Transformers-based design reduces computational costs and allows for real-time object detection.

**Key Features**
  Efficient Hybrid Encoder: Baidu's RT-DETR uses an efficient hybrid encoder that processes multiscale features by decoupling intra-scale interaction and cross-scale fusion. This unique Vision Transformers-based design reduces computational costs and allows for real-time object detection.
  IoU-aware Query Selection: Baidu's RT-DETR improves object query initialization by utilizing IoU-aware query selection. This allows the model to focus on the most relevant objects in the scene, enhancing the detection accuracy.
  Adaptable Inference Speed: Baidu's RT-DETR supports flexible adjustments of inference speed by using different decoder layers without the need for retraining. This adaptability facilitates practical application in various real-time object detection scenarios.

 a) PyTorch and TensorFlow are two of the most popular deep learning frameworks. Both frameworks have their own strengths and weaknesses, and the best choice for you will depend on your specific needs.

 b) PyTorch is a Python-based deep learning framework that is known for its flexibility and ease of use. PyTorch uses a dynamic computation graph, which allows you to create and modify your models on the fly. This makes PyTorch a good choice for rapid prototyping and experimentation.

 c) TensorFlow is another Python-based deep learning framework that is known for its scalability and performance. TensorFlow uses a static computation graph, which means that you need to define your model before you can start training it. This can make TensorFlow less flexible than PyTorch, but it also makes TensorFlow more efficient for training large models.

Compute Unified Device Architecture (CUDA) is a parallel computing platform and application programming interface (API) that allows software to use certain types of graphics processing units (GPUs) for accelerated general-purpose processing, an approach called general-purpose computing on GPUs (GPGPU).

a) Check if CUDA is available:

   import torch
   print(torch.cuda.is_available())

b) Check the CUDA device count:

   print(torch.cuda.device_count())

c) Check the CUDA device properties:

   for i in range(torch.cuda.device_count()):

     print(torch.cuda.get_device_properties(i))

d) Check the current CUDA device:

   print(torch.cuda.current_device())

  a) Check if CUDA is available:

      import tensorflow as tf

      print(tf.test.is_built_with_cuda())

  b) Check the CUDA device count:

      print(len(tf.config.experimental.list_physical_devices('GPU')))


  c) Check the CUDA device properties:

      gpus = tf.config.experimental.list_physical_devices('GPU')
      for gpu in gpus:
          print("Name:", gpu.name, "  Type:", gpu.device_type)

  d) Check the current CUDA device:

      print(tf.config.experimental.get_visible_devices('GPU'))

  A tensor is a mathematical object representing a multi-dimensional array of numerical values. In the context of machine learning frameworks like TensorFlow and PyTorch, tensors are the fundamental data structures used for computation.

a) Dimensionality:

b) Data Types:

c) Operations:

d) Memory Layout:

e) Gradient Computation:

Tensors and NumPy arrays are both used to represent multi-dimensional arrays of numerical data, but they have some differences, especially in the context of machine learning frameworks like TensorFlow and PyTorch.

a) Integration with Deep Learning Frameworks:

b) Computation on Accelerators:

c) Automatic Differentiation:

d) Memory Sharing:

  REST API stands for Representational State Transfer Application Programming Interface. It is an architectural style for designing networked applications. RESTful APIs are designed to be simple, lightweight, and scalable, making them popular for building web services and APIs.

  a) Statelessness:

  b) Resources and URIs:

  c) HTTP Methods:

  d) Representation:

  e) Uniform Interface:

  f) State Transfer:

  RESTful APIs are widely used in web development for building web services, mobile applications, and IoT (Internet of Things) devices. They provide a flexible and scalable way to expose functionality over the web, allowing different clients to interact with server-side resources using standard protocols and formats.

Pytorch :

  import torch

  ##Create a tensor on CPU 
  tensor_cpu = torch.tensor([1, 2, 3])
  
  #Transfer tensor from CPU to GPU
  tensor_gpu = tensor_cpu.to('cuda')  # or tensor_cpu.cuda()
  
  #Transfer tensor from GPU to CPU
  tensor_cpu_again = tensor_gpu.to('cpu')  # or tensor_gpu.cpu()

TensorFlow:

  Model1:

      import tensorflow as tf
  
      #Create a tensor on CPU
      tensor_cpu = tf.convert_to_tensor([1, 2, 3])
      
      #Transfer tensor from CPU to GPU
      with tf.device('/gpu:0'):  # Change '0' to the GPU device index you want to use
          tensor_gpu = tf.identity(tensor_cpu)  # or tf.identity(tensor_cpu).gpu()
      
      #Transfer tensor from GPU to CPU
      tensor_cpu_again = tf.identity(tensor_gpu)  # or tf.identity(tensor_gpu).cpu()

  Model2:

      import tensorflow as tf

      #Create a tensor on CPU
      tensor_cpu = tf.constant([1, 2, 3])
      
      #Transfer tensor from CPU to GPU
      tensor_gpu = tf.convert_to_tensor(tensor_cpu)
      with tf.device('/gpu:0'):  # Change '0' to the GPU device index you want to use
          tensor_gpu = tf.identity(tensor_gpu)
      
      #Transfer tensor from GPU to CPU
      tensor_cpu_again = tensor_gpu.numpy()

a) Activation functions, also known as transfer functions, are used in neural networks to calculate the weighted sum of inputs and biases, which then determines if a neuron can be activated. They also manipulate the presented data and produce an output for the neural network that contains the parameters in the data. Activation functions can be linear or nonlinear, and are used to control the output of neural networks across different domains.

b) Activation functions introduce non-linearities to neural networks, enabling them to learn complex patterns and make non-linear predictions. For example, the sigmoid function is commonly used in artificial neural networks, particularly in feedforward neural networks, because it allows the network to introduce non-linearity into the model, which allows the neural network to learn more complex decision boundaries.

c) Here are some examples of activation functions:

    1) ReLU:

        The most used activation function in the world, used in almost all the convolutional neural networks or deep learning.

    2) Leaky ReLU:

        An improved version of the ReLU function, where the gradient is 0 for x<0, which would deactivate the neurons in that region.

    3) tanh:

        Also called the hyperbolic tangent activation function, this mathematical function commonly used in artificial neural networks for their hidden layers. It transforms input values to produce output values between -1 and 1.

    4) Linear:

        Also known as "no activation," or "identity function" (multiplied x1.0), this function doesn't do anything to the weighted sum of the input, it simply spits out the value it was given.

a) Method 1 is deleting rows or columns.

    We usually use this method when it comes to empty cells.
    For example, if the majority of our data is missing for a column or for a row, we can simply delete them.

b) Method 2 is replacing the missing data with aggregated values.

    In this case, we can calculate the aggregated value based on the rest of the values we have in the column and put the received number to the empty spot.

c) Method 3 is creating an unknown category.

    Categorical features have a number of possible values, which gives us an opportunity to create one more category for the missing values. This way we will lower the variance by adding new information to the data. This could be used when the original information is missing or cannot be understood,

d) Method 4 is predicting missing values.

    where we have no missing values, we can train a statistical or machine learning algorithm in order to predict the missing values. Since among the samples for which this training is performed, there are missing values, it is necessary to replace them initially using one of the simplest methods for recovering gaps. This way will give us better performance, unless, of course, a missing value should have a high variance. As always, an example. With Madan here, we don’t have any number for the experience column. If we have a bigger table, with more people with similar information — the same country, profession, and education — it is possible to calculate correctly the most possible result for the missing feature. In this case, even if we didn’t guess absolutely right.

Random seed is used to ensure that results are reproducible. This is important in data science and other fields. For example, in Python, random seed is used to generate a pseudo-random encryption key, which is an important part of computer security. Random seed also makes optimization of codes easy where random numbers are used for testing.

```
  import random

  random.seed(10)
  print(random.random())
  
  random.seed(10)
  print(random.random())

Model for real time detection.

Yolov1 : problem with Small objects.

Yolov2 : Bounding boxes + Multi class

Yolov3 : Pyramid n/w's

    Different scales and resolutions

Yolov4 : Accuracy and speed

    CSPDarknet53 as the backbone network, Mish activation function, and improved data augmentation.

Yolov5 :

Yolov8 :

    Along with its versatility, YOLOv8 boasts several other innovations that make it a strong candidate for a wide range of object detection and image segmentation tasks. These include a new backbone network, anchor-free detection head, and loss function. Additionally, YOLOv8 is highly efficient and can run on a variety of hardware, from CPUs to GPUs.

Yolov9:

    This model is superior to RT-DETR and YOLO-MS in terms of accuracy and efficiency, setting new standards in lightweight model performance.

CNN stands for Convolutional Neural Network, which is a class of deep neural networks commonly used in tasks involving visual imagery analysis, such as image classification, object detection, and image segmentation.

Here's a breakdown of CNNs and their components:

  1) Convolutional Layers : These are the fundamental building blocks of CNNs. Convolutional layers apply convolution operations to the input data using filters (also called kernels) to extract features. The filters slide over the input data, computing dot products at each position, which helps capture **spatial patterns and local dependencies in the data**.

  2) Pooling Layers: Pooling layers are typically inserted between convolutional layers to **reduce the spatial dimensions of the feature maps** while retaining the most important information. Common **pooling operations include max pooling and average pooling, which downsample the input by taking the maximum or average** value within each pooling region.

  3) Activation Functions: **Activation functions introduce non-linearity into the network**, allowing **CNNs to learn complex patterns and relationships in the data**. Popular activation functions used in CNNs include ReLU (Rectified Linear Unit), sigmoid, and tanh.

  4) Fully Connected Layers: Fully connected layers, also known as dense layers, are typically found at the end of a CNN architecture. These layers connect every neuron in one layer to every neuron in the next layer, allowing the network to learn high-level features and make predictions based on the extracted features.

  5) Flattening: Before passing the output of convolutional and pooling layers to fully connected layers, the feature maps are flattened into a one-dimensional vector. This flattening operation reshapes the data into a format suitable for input to the fully connected layers.

**CNNs** are trained using **backpropagation and gradient descent algorithms**, where the network learns to minimize a loss function by adjusting its weights and biases during the training process. They are particularly effective in handling high-dimensional data like images due to their ability to automatically learn hierarchical representations of features directly from the raw data.

	GridSearchCV is a technique for finding the optimal parameter values from a given set of parameters in a grid. It's essentially a cross-validation technique. The model as well as the parameters must be entered. After extracting the best parameter values, predictions are made

	```
    params = dict()
 
    params["C"] = (1e-6,1,10,100.0 )
 
    params["gamma"] = (1e-6,1,10,100.0)
 
    params["degree"] = (1,2,3)
 
    params["kernel"] = ['linear','poly', 'rbf', 'sigmoid']

# Will error (requires the .assign() method)
changeable_tensor[0] = 7
changeable_tensor
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-14-daecfbad2415> in <cell line: 2>()
      1 # Will error (requires the .assign() method)
----> 2 changeable_tensor[0] = 7
      3 changeable_tensor

TypeError: 'ResourceVariable' object does not support item assignment
To change an element of a tf.Variable() tensor requires the assign() method.

# Won't error
changeable_tensor[0].assign(7)
changeable_tensor

1. Set: Sets are associative containers that store unique elements following a specific order. Following are the properties of sets:

	Stores the values in sorted order. 
	Stores only unique values. 
	Elements can only be inserted or deleted but cannot be modified. 
	We can erase more than 1 element by giving the start iterator and end iterator position. 
	Traversal using iterators. 
	Sets are implemented as Binary Search Tree.

3. Multisets: Multisets are associative containers that store multiple elements having equivalent values following a specific order. Following are the properties of multisets:

	Stores elements in sorted order.

	It allows the storage of multiple elements.

	We can erase more than 1 element by giving the start iterator and end iterator.

3. unordered_set: unordered_set are associative containers that store unique elements in no particular order. Following are the properties of Unordered_sets: 

	Elements can be stored in any order. ( no sorted order )

	Stores only unique values.

	Hash-table used to store elements.

	We can erase only the element for which the iterator position is given.

4. Unordered_multiset: Unordered_multiset is an associative container that contains a set of non-unique elements in unsorted order. Following are the properties of Unordered_multiset: 

	Elements can be stored in any order.

	Duplicate elements can be stored.

	Hash-table used to store elements.

	We can erase only the element for which the iterator position is given.

Map stores unique key-value pairs in a sorted manner. Each key is uniquely associated with a value that may or may not be unique. A key can be inserted or deleted from a map but cannot be modified. Values assigned to keys can be changed. It is a great way for quickly accessing value using the key and it is done in O(1) time.

Multimap is similar to map with an addition that multiple elements can have same keys. Also, it is NOT required that the key value and mapped value pair has to be unique in this case. One important thing to note about multimap is that multimap keeps all the keys in sorted order always. These properties of multimap makes it very much useful in competitive programming.

Backpropagation is the process of computing the gradient of the loss function with respect to each weight in the network, layer by layer, starting from the output layer and moving backward to the input layer. This gradient represents the **direction and magnitude of change that each weight should undergo to minimize the loss function.**

	def how_may_substrings(main,sub):
    number =0 
    if len(main) > len(sub):
        main,sub=main,sub
    else:
        main,sub = sub,main
    main_len =len(main)
    sub_len = len(sub)
    print(main_len,sub_len)
    for i in range(0,main_len-sub_len+1):
        print(main[i:i+sub_len])
        if (main[i:i+sub_len]==sub):
            number+=1
    return number

print(how_may_substrings("abababa","aaaba"))

	Greedy search and beam search are both search algorithms used in machine learning and natural language processing (NLP) tasks. They differ in how they make decisions during the search process:

	Greedy search Selects the single most likely option. It's simple and fast, but it only considers each position in isolation.

	Beam search Maintains a beam of multiple candidates at each step, ranked based on their probabilities. It's more complex and computationally expensive than greedy search, but it's more accurate because it considers future steps when selecting the next word.

https://learnopencv.com/super-resolution-in-opencv/

Super-resolution refers to the process of upscaling or improving the details of the image. Follow this blog to learn the options for Super Resolution in OpenCV. When increasing the dimensions of an image, the extra pixels need to be interpolated somehow. Basic image processing techniques do not give good results as they do not take the surroundings in context while scaling up. Deep learning and, more recently, GANs come to the rescue here and provide much better results.

1) Resnet architecture

2) Residual Blocks are skip-connection blocks that learn residual functions with reference to the layer inputs, instead of learning unreferenced functions. They were introduced as part of the ResNet architecture.

3) Different techniques:
		a) EDSR : Enhanced deep resdiual network. it is slower than FSRCNN.
  		b) FSRCNN : 
	c) LapSRN : Same results as FSRCNN.
	d) ESPCN : Same speed as FSRCNN , giving less count than fsrcnn.

def anagrom(first,second):
    true_or_false = True
    if first!=second:
        true_or_false= False
    return true_or_false
        
print(anagrom(["a",2,"df"],["a",2,"df"]))

1) A convolutional layer is the main building block of a CNN. It contains a set of filters (or kernels), parameters of which are to be learned throughout the training. The size of the filters is usually smaller than the actual image. Each filter convolves with the image and creates an activation map.

2) A hidden layer in a neural network is a layer of neurons that is neither the input nor output layer. The term "hidden" refers to the fact that these layers are not directly observable and are responsible for the depth of neural networks, allowing them to process complex data representations.

3) The purpose of the pooling layers is to reduce the dimensions of the hidden layer by combining the outputs of neuron clusters at the previous layer into a single neuron in the next layer

n1 X n2 =>  (((n1-f)/s)+1) * (((n2-f)/s)+1)
n - input image size
f - filter size
s - stride size

example : 6 X 7 image size , filter(f=2) and stride is 3

	(((6-2)/3)+1) * (((7-2)/3)+1)

n1 X n2 =>  (((n1-f+2p)/s)+1) * (((n2-f+2p)/s)+1)

(((n1-2+2p)/3)+1) * (((n2-2+2p)/3)+1)

k=4
end =7

second_final=[]

index = 0
for i in range(end):
    if i > k-1:
        sum= 0

        for t in second_final[index : len(second_final)]:
            print("fatat : ",index)
            sum+=t
        index+=1

        second_final.append(sum)

    else:
        second_final.append(1)

data =[33,2,33,1,2,45,2,4,-1,4,23]

data =[1,2,3,4,4]

for i in range(len(data)-1):
    tr_fal = False
    
    for j in range(len(data)-1-i):
        
        if data[j]>data[j+1]:
            tr_fal = True
            
            data[j],data[j+1] = data[j+1],data[j]
    
    if tr_fal == False:
        print(tr_fal)
        break
    
    
print(data)

for i in range(len(data)-1):

    tr_fal = False
    for j in range(i+1,len(data)):
        
        if data[i]>data[j]:
            tr_fal = True
            
            data[i],data[j] = data[j],data[i]
        
    
    if tr_fal == False:
        print(tr_fal)
        break

print(data)

data =[10,15,9,-1,0]
for i in range(1,len(data)):
    
    j = i-1
    mid = data[i]
    
    while j>=0 and  data[j]  > mid:
        
        data[j+1] = data[j]
        j-=1
    
    data[j+1] = mid
    

print(data)

class Dog:
    # Class variable to count the number of dogs
    number_of_dogs = 0
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Dog.number_of_dogs += 1

    def description(self):
        return f"{self.name} is {self.age} years old"
    
    # @classmethod
    # def get_number_of_dogs(cls):
    def get_number_of_dogs(self):
        # return cls.number_of_dogs
        return self.number_of_dogs

# Create instances
dog1 = Dog("Buddy", 3)
dog2 = Dog("Bella", 5)

dog2 = Dog("Bella", 5)

data = dog2

# Access class variable
print(data.get_number_of_dogs())  # Output: 2

**a) Single Responsibility Principle**

	Only for one purpose.

**b) Open-Closed Principle**

	Posi        Negative
      ---------------------------------

	  ---------------------------------

	  ---------------------------------
   
   Recall = TP/(TP+FN)

Accuracy = (TP+TN)/(TP+TN+FP+FN)

Gradient descent is an optimization algorithm used to minimize the loss function in machine learning and neural networks. It is a method for finding the minimum of a function by iteratively moving towards the steepest descent, as defined by the negative of the gradient.

**Loss Function:**

	The loss function (or cost function) measures the difference between the predicted values and the actual target values. The goal of training a neural network is to minimize this loss function.
**Gradient:**

	The gradient is a vector of partial derivatives of the loss function with respect to each parameter (weights and biases) of the model. It points in the direction of the steepest increase in the loss function.

**The gradient descent algorithm involves the following steps:**

Initialization, Compute the Loss, Compute the Gradient, Update Parameters and Repeat

Gradient descent primarily occurs during backpropagation in the context of training neural networks. Here's a brief overview of the process:

Backward Propagation (Backpropagation):

The calculated error from forward propagation is propagated back through the network.

Gradients of the loss function with respect to the weights and biases are computed using the chain rule of calculus.

These gradients indicate how much the weights and biases need to be adjusted to reduce the error.

Therefore, while forward propagation is about calculating the output and the loss, gradient descent (the optimization step) takes place during backpropagation, where the gradients are used to update the model's parameters.

Reducing or optimizing the gradient descent process can involve several strategies to improve the efficiency and effectiveness of training a neural network. Here are some key techniques:

a) Learning Rate Adjustment:

b) Gradient Clipping:

c) Batch Normalization:

  	Batch normalization normalizes the input to each layer so that they have a mean of zero and a variance of one

d) Momentum

e) Optimization Algorithms:

f) Regularization Techniques:

 	1) randomly selected neurons are ignored during training
	L1/L2 Regularization.

 		
	2) Regularization is a technique used in machine learning to prevent overfitting, which occurs when a model learns the training data too well, capturing noise and fluctuations rather than the underlying pattern. Regularization adds additional constraints or penalties to the model to ensure it generalizes better to unseen data. Here are the most common regularization techniques:

g) Proper Initialization:

h) Mini-Batch Gradient Descent:

i) Data Augmentation and Preprocessing:

j) Early Stopping:

a) data Augmentation : random crops, rotations, flips, color jittering(torch.transform)

b) Regularization : 

c) Dropout:

	1) Use dropout layers in your n/w to randomly set some activation to zero during training.

d) Batch normalization: 

	1) Normalize the activations of the layers to improve convergence and regularization.

	2) Batch Normalization (BatchNorm) is a technique to improve the training of deep neural networks by normalizing the inputs to each layer, which helps in accelerating training and reducing the 				sensitivity to network initialization

e) Early stopping:

f) Smaller model: 
  
  	1) Reduce the complexity of your model by decreasing the number of layers or the number of units per layer.

g) More data:
   	1) Collect more training data if possible to improve generalization.

a) Increase model complexity:

b) Increase Training Duration:

c) Learning Rate Tuning:

	1) Ensure the learning rate is neither too high nor too low. If too high, the model may converge prematurely to a suboptimal solution. If too low, the model may converge too slowly or get stuck.

d) Reduce Regularization:
	
 	1) If you are using regularization techniques like dropout or weight decay, try reducing them as they can sometimes prevent the model from learning effectively.

e) Data Preprocessing:

f) Use Pretrained Models:

g) Batch Normalization:

a) In machine learning, an epoch is one complete pass through the entire training dataset during the training process of a model. Training typically involves multiple epochs to improve the model's accuracy.

a) Leverages Prelearned Features:
    
    Pretrained models are typically trained on large and diverse datasets, such as ImageNet, which contains millions of images across thousands of categories. These models learn a variety of features that are generally useful for many tasks, such as edges, textures, and shapes. When you use a pretrained model, you start with a network that already knows these useful features, providing a strong foundation.

b) Reduces Training Time:
    Training a deep neural network from scratch can be computationally expensive and time-consuming. Transfer learning allows you to start from an already trained model, requiring only a fraction of the time and computational resources to fine-tune the network for your specific task.

c) Improves Performance with Limited Data:
    
    When you have a small dataset, training a deep network from scratch can lead to overfitting. Pretrained models, on the other hand, help mitigate this by starting from a set of weights that generalize well, thus needing fewer data to fine-tune the model effectively.

d) Provides Robust Feature Extraction:
    
    Pretrained models are effective feature extractors. Even if you only retrain the final layers, the earlier layers can provide robust and meaningful features for your specific problem, improving overall model performance.

Practical Steps to Leverage Transfer Learning for Better Results:

    1) Choosing pre-trained model, modify the model, freezing layer, fine tunning, Data augmentation, hyper parameters, Regularization techniques.

Both GridSearchCV and RandomSearchCV are techniques used in machine learning for hyperparameter tuning, which is the process of finding the best hyperparameters for a machine learning model.

GridSearchCV:

    Slow, High computational power, Detecting for every combination of parameters, Not feasible for high-dimensional hyperparameter spaces, results same.

Randomsearchcv:

    Fixed noof hyperparameters combinations, high efficiency, less computational power.

Choosing between GridSearchCV and RandomSearchCV depends on the specific needs of your project. If you have a small hyperparameter space and want to ensure finding the best parameters, GridSearchCV is the way to go. If you have a large hyperparameter space or limited computational resources, RandomSearchCV is typically more efficient and can still yield good results.

a) Enables m/c to take decisions on their own. based on past data.                       a) Enables m/c's to take decesions with the help ofartificial neural n/w's.

b) Needs only small amount of data.                                                      b) Needs a large amount of training data.

c) Works well on low-end systems.                                                        c) Needs high end s/m to work.

d) Most features need to identified in advanced and manually coded.                      d) learns features from the data provided.

e) The Problem is divided into parts and solved individually and then combined.          e) The problem is solved in an end-to-end manner.

Finance: Supervised learning helps detect fraudulent transactions, predict stock prices, and assess creditworthiness.

Marketing: It helps personalize marketing campaigns, predict customer churn, and score leads.

Sales: It helps improve dynamic pricing models.

Customer service: It helps create chatbots that provide real-time recommendations and on-demand help.

Security: It helps identify suspicious transactions and prevent fraud.

Image recognition: It helps computers recognize objects in images.

Spam detection: It helps identify and prevent spam emails.

Healthcare: It helps clinicians make diagnoses and choose treatment options.

Manufacturing: It helps with quality control.

a) Spam Detection: In email spam detection, it's crucial to minimize the number of legitimate emails marked as spam (false positives). High precision ensures that the emails classified as spam are indeed spam, even if some spam emails are missed (lower recall).

b) Medical Diagnosis: In medical testing, particularly when screening for a serious but not immediately life-threatening condition, it might be more important to ensure that a positive result is truly indicative of the condition. For instance, a diagnostic test for a rare condition should have high precision to avoid unnecessary stress and further invasive testing on healthy patients.

c) Fraud Detection: In financial transactions, identifying fraudulent activities should have high precision to prevent normal transactions from being flagged as fraudulent. False positives could inconvenience customers and lead to a loss of trust in the financial institution.

d) Search Engines and Recommendation Systems: In these applications, it is often more important that the returned results are highly relevant (high precision), even if it means some relevant results are missed (lower recall). Users typically prefer highly accurate results rather than sifting through numerous irrelevant ones.

e) Legal Document Review: In e-discovery and legal document review, it's essential that the documents identified as relevant are indeed relevant to avoid legal risks and inefficiencies. High precision is preferred to ensure that the relevant documents are identified correctly.

f) Advertising: In targeted advertising, ensuring that the ads shown are highly relevant to the user (high precision) can improve user experience and engagement, even if it means some potential customers are not shown the ad (lower recall).

1) Image segmentation

    A process that involves labeling pixels in an image:
    
        a) Instance segmentation: Assigns a unique label to each pixel to differentiate between different instances of the same class
    
        b) Panoptic segmentation: A combination of semantic and instance segmentation that labels each pixel with a class label and identifies each object instance in the image
    
        c) DBSCAN clustering: Groups pixels into clusters based on their density.

2) Market segmentation

    A process that involves grouping buyers based on characteristics that may influence their behavior:
    
    Behavioral segmentation: Based directly on consumer behavior
    
    Geographic segmentation: Groups buyers by physical location, which can influence buying habits due to climate or resource access
    
    Demographic segmentation: Segments customers based on demographic factors, such as characteristics of a person or population
    
    Psychographic segmentation: Studies consumers based on their mental attributes, such as interests, values, lifestyle, income, and beliefs

3) User segmentation
    A process that involves segmenting customers based on characteristics:
    
    Supervised segmentation: Involves the marketer establishing predefined rules, and machine learning organizes the data according to those rules

For capturing complex pattern

a) Sigmoid function:

	S(x)= {1}/{1+e^{-x}}

  	Range (0,1)

	Vanishing gradent

b) tanh : 
    
    ((e**x −e ** −x)/(e **x + e **−x))

    range : (-1,1)

    vanishing gradent

c) relu:

    S(x) = max(0,1)

    range : (0,inf)

    mitigate vanishing gradent

    dead neurons 

d) leaky - relu:

    range = (-inf,inf)

    S(x) = max(0.01x,x)

    prevent dead neurons

    Computational over head

e) Softmax:

    Used in the o/p layer of classification n/w's to represent possibilites.

measures how well a machine learning model performs.

a) Regression loss:

    i) Mean squared error:

    ii) Mean Absolute error:

    iii) Huber Loss:

b) Classification loss:

    i) Binary cross entropy:

    ii) Categorical cross entropy:

    iii) Sparse categorical cross entropy:

c) Specialized loss functions:

    i) Kullback-leibler

    ii) Hinge loss

    iii) cosine similarity

    iv) Dice loss: