Merge branch 'main' into m2

Author: ajay-dhangar

blog/getting-started-with-serverless-architecture.md

@@ -0,0 +1,206 @@
+---
+title: 'Getting Started with Serverless Architecture Using AWS Lambda'
+sidebar_label: Serverless Architecture and AWS Lambda
+authors: [nayanika-mukherjee]
+tags: [serverless, AWS Lambda, cloud computing, Python, technology]
+date: 2024-07-22
+hide_table_of_contents: true
+---
+
+## Introduction
+
+Serverless architecture is a cloud computing execution model where the cloud provider dynamically manages the allocation and provisioning of servers. AWS Lambda, a key component of serverless architecture, allows you to run code without provisioning or managing servers. This guide will introduce you to AWS Lambda and provide a step-by-step approach to getting started with serverless architecture.
+
+## Key Concepts
+
+### What is AWS Lambda?
+
+AWS Lambda is a compute service that lets you run code in response to events and automatically manages the compute resources required by that code. You pay only for the compute time you consume.
+
+### Serverless Benefits
+
+- **No Server Management:** No need to provision or manage servers.
+- **Scalability:** Automatically scales your application by running code in response to each trigger.
+- **Cost Efficiency:** Pay only for the compute time you consume.
+
+### Event Sources
+
+Lambda can be triggered by various AWS services such as S3, DynamoDB, Kinesis, SNS, and more.
+
+## Setting Up AWS Lambda
+
+### Prerequisites
+
+- An AWS account.
+- AWS CLI installed and configured.
+- Basic knowledge of Python (or the language you choose for your Lambda functions).
+
+### Creating an IAM Role
+
+Before creating a Lambda function, you need an IAM role that Lambda assumes when it executes your function.
+
+```bash
+aws iam create-role --role-name lambda-execution-role --assume-role-policy-document file://trust-policy.json
+```
+`trust-policy.json`:
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "lambda.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+```
+Attach the necessary policies to the role:
+```bash
+aws iam attach-role-policy --role-name lambda-execution-role --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+```
+
+## Writing and Deploying Lambda Functions
+
+### Basic Lambda Function
+Here is a simple Python function that returns a greeting.
+
+`lambda_function.py`:
+```python
+def lambda_handler(event, context):
+    return {
+        'statusCode': 200,
+        'body': 'Hello, World!'
+    }
+```
+
+### Creating and Deploying the Function
+- Create a ZIP file containing your code:
+```bash
+zip function.zip lambda_function.py
+```
+
+- Deploy the Lambda Function:
+```bash
+aws lambda create-function --function-name HelloWorldFunction \
+--zip-file fileb://function.zip --handler lambda_function.lambda_handler \
+--runtime python3.8 --role arn:aws:iam::123456789012:role/lambda-execution-role
+```
+
+## Lambda Execution Model
+
+Lambda functions have an execution model that includes:
+
+- Invocation: Functions can be invoked synchronously or asynchronously.
+- Concurrency: Lambda automatically scales to handle the incoming requests.
+- Execution Duration: You can configure the timeout for your function (default is 3 seconds, maximum is 15 minutes).
+
+## Managing Lambda Functions
+- Updating a Function
+To update the function code:
+```bash
+zip function.zip lambda_function.py
+aws lambda update-function-code --function-name HelloWorldFunction --zip-file fileb://function.zip
+```
+
+- Monitoring and Logging
+AWS Lambda integrates with Amazon CloudWatch to provide monitoring and logging. You can view logs by navigating to the CloudWatch Logs in the AWS Management Console.
+
+## Advanced Topics
+
+### Environment Variables
+You can use environment variables to pass configuration settings to your Lambda function.
+```bash
+aws lambda update-function-configuration --function-name HelloWorldFunction \
+--environment "Variables={ENV_VAR1=value1,ENV_VAR2=value2}"
+```
+### Layers
+Lambda layers allow you to package libraries and other dependencies separately from your function code.
+
+- Create a layer:
+```bash
+zip -r myLayer.zip python/
+aws lambda publish-layer-version --layer-name myLayer --zip-file fileb://myLayer.zip
+```
+### VPC Integration
+You can configure your Lambda function to access resources in a VPC.
+```bash
+aws lambda update-function-configuration --function-name HelloWorldFunction \
+--vpc-config SubnetIds=subnet-abc123,SecurityGroupIds=sg-abc123
+```
+
+## Performance and Scaling
+
+### Cold Starts
+A cold start occurs when a new instance of the function is invoked after being idle. To mitigate cold starts:
+
+- Optimize initialization code.
+- Use Provisioned Concurrency for predictable performance.
+
+### Concurrency Limits
+You can configure reserved concurrency to limit the number of concurrent executions:
+```bash
+aws lambda put-function-concurrency --function-name HelloWorldFunction --reserved-concurrent-executions 10
+```
+## Testing and Debugging
+
+### Local Testing
+Use the AWS SAM CLI to test Lambda functions locally:
+```bash
+sam local invoke HelloWorldFunction -e event.json
+```
+
+### Debugging
+Utilize CloudWatch Logs to debug issues by adding log statements in your code:
+```python
+import logging
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+def lambda_handler(event, context):
+    logger.info("Event: %s", event)
+    return {
+        'statusCode': 200,
+        'body': 'Hello, World!'
+    }
+```
+## Real-World Examples
+
+### S3 Event Trigger
+Trigger a Lambda function when an object is uploaded to an S3 bucket:
+```python
+import json
+
+def lambda_handler(event, context):
+    for record in event['Records']:
+        s3 = record['s3']
+        bucket = s3['bucket']['name']
+        key = s3['object']['key']
+        print(f'Received event. Bucket: {bucket}, Key: {key}')
+    return {
+        'statusCode': 200,
+        'body': json.dumps('Processed S3 event')
+    }
+```
+
+### DynamoDB Stream
+Process DynamoDB stream events:
+```python
+import json
+
+def lambda_handler(event, context):
+    for record in event['Records']:
+        if record['eventName'] == 'INSERT':
+            new_image = record['dynamodb']['NewImage']
+            print(f'New item added: {new_image}')
+    return {
+        'statusCode': 200,
+        'body': json.dumps('Processed DynamoDB stream event')
+    }
+```
+
+## Conclusion
+
+AWS Lambda provides a powerful and flexible way to build serverless applications. By understanding its key concepts, setting up your environment, and leveraging advanced features, you can build scalable and cost-efficient solutions. This guide serves as a starting point for your journey into serverless architecture using AWS Lambda.

docs/Deep Learning/Backpropogation in ANN.md

@@ -0,0 +1,120 @@
+
+# Backpropagation in Neural Networks
+
+## Overview
+
+Backpropagation is a fundamental algorithm used for training artificial neural networks. It computes the gradient of the loss function with respect to each weight by the chain rule, efficiently propagating errors backward through the network. This allows for the adjustment of weights to minimize the loss function, ultimately improving the performance of the neural network.
+
+
+
+
+# How Backpropagation Works
+
+## Forward propogation
+
+- Input Layer: The input data is fed into the network.
+- Hidden Layers: Each layer performs computations using weights and biases to transform the input data.
+- Output Layer: The final transformation produces the output, which is compared to the actual target to calculate the loss.
+
+### Mathematical Formulation
+$$
+a_i^l = f\left(z_i^l\right) = f\left(\sum_j w_{ij}^l a_j^{l-1} + b_i^l\right)
+$$
+
+
+where f is the activation function, zᵢˡ is the net input of neuron i in layer l, wᵢⱼˡ is the connection weight between neuron j in layer l — 1 and neuron i in layer l, and bᵢˡ is the bias of neuron i in layer l.
+
+## Backward propogation
+
+- Compute Loss: Calculate the error (loss) using a loss function (e.g., Mean Squared Error, Cross-Entropy Loss).
+- Error Propagation: Propagate the error backward through the network, layer by layer.
+- Gradient Calculation: Compute the gradient of the loss with respect to each weight using the chain rule.
+- Weight Update: Adjust the weights by subtracting the gradient multiplied by the learning rate.
+
+### Mathematical Formulation
+
+- The loss function measures how well the neural network's output matches the target values. Common loss functions include:
+1) **Mean Squared Error (MSE):**
+   
+$$
+L = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2
+$$ 
+1) **Cross-Entropy Loss:**
+
+$$ 
+L = -\frac{1}{n} \sum_{i=1}^{n} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right]
+$$
+
+
+- For each weight 𝑤 in the network, the gradient of the loss L with respect to w is computed as:
+  
+$$
+\frac{\partial L}{\partial w} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial w}
+$$
+
+
+- Weights are updated using the gradient descent algorithm:
+  
+$$
+w \leftarrow w - \eta \frac{\partial L}{\partial w}
+$$
+
+# Backpropogation from scratch
+
+
+
+```bash
+  import numpy as np
+
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+
+def sigmoid_derivative(x):
+    return x * (1 - x)
+
+# Input data
+X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
+y = np.array([[0], [1], [1], [0]])
+
+# Initialize weights and biases
+np.random.seed(42)
+weights_input_hidden = np.random.rand(2, 2)
+weights_hidden_output = np.random.rand(2, 1)
+bias_hidden = np.random.rand(1, 2)
+bias_output = np.random.rand(1, 1)
+learning_rate = 0.1
+
+# Training 
+
+for epoch in range(10000):
+
+    # Forward pass
+    hidden_input = np.dot(X, weights_input_hidden) + bias_hidden
+    hidden_output = sigmoid(hidden_input)
+    final_input = np.dot(hidden_output, weights_hidden_output) + bias_output
+    final_output = sigmoid(final_input)
+
+    # Error
+    error = y - final_output
+    d_output = error * sigmoid_derivative(final_output)
+
+    # Backward Propogation ( gradient decent)
+    error_hidden = d_output.dot(weights_hidden_output.T)
+    d_hidden = error_hidden * sigmoid_derivative(hidden_output)
+
+    # Update weights and biases
+    weights_hidden_output += hidden_output.T.dot(d_output) * learning_rate
+    bias_output += np.sum(d_output, axis=0, keepdims=True) * learning_rate
+    weights_input_hidden += X.T.dot(d_hidden) * learning_rate
+    bias_hidden += np.sum(d_hidden, axis=0) * learning_rate
+
+print("Training complete")
+print("Output after training:")
+print(final_output)
+
+```
+
+
+## Conclusion
+
+Backpropagation is a powerful technique for training neural networks(ANN), enabling them to learn complex patterns and make accurate predictions. Understanding the mechanics and mathematics behind it is essential to Understand inner woking of an ANN.