Merge branch 'main' into main

Author: ajay-dhangar

blog/Quantum computing and it's application.md

@@ -0,0 +1,91 @@
+---
+title: "Introduction to Quantum Computing and Its Applications"
+sidebar_label: Quantum Computing
+authors: [pujan-sarkar]
+tags: [Quantum Computing, Applications]
+date: 2024-07-22
+---
+
+## Quantum Computing: Basics and Applications
+
+Quantum computing is a revolutionary field that leverages the principles of quantum mechanics to process information in fundamentally different ways compared to classical computing. This blog will introduce the basics of quantum computing, explore its potential applications, and provide resources for further learning.
+
+## Introduction to Quantum Computing
+
+Quantum computing harnesses the peculiar principles of quantum mechanics, such as superposition and entanglement, to perform computations that would be infeasible for classical computers. While classical computers use bits as the smallest unit of information (which can be 0 or 1), quantum computers use quantum bits, or qubits, which can represent both 0 and 1 simultaneously due to superposition.
+
+## Basic Concepts
+
+### Quantum Bits (Qubits)
+
+A qubit is the fundamental unit of quantum information. Unlike a classical bit, which can be either 0 or 1, a qubit can exist in a state that is a linear combination of both. This property is called superposition. Mathematically, a qubit's state can be represented as:
+
+$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$
+
+where $|\alpha|^2$ and $|\beta|^2$ are the probabilities of the qubit being in the state $|0\rangle$ and $|1\rangle$ respectively, and $|\alpha|^2 + |\beta|^2 = 1$.
+
+### Superposition
+
+Superposition is the ability of a quantum system to be in multiple states simultaneously. For qubits, this means they can represent both 0 and 1 at the same time. This property enables quantum computers to process a vast amount of possibilities simultaneously, providing an exponential speed-up for certain computations.
+
+### Entanglement
+
+Entanglement is a quantum phenomenon where two or more qubits become correlated in such a way that the state of one qubit instantly influences the state of the other, regardless of the distance between them. This correlation is a key resource for quantum computing, enabling complex operations and secure communication protocols.
+
+### Quantum Gates
+
+Quantum gates are the building blocks of quantum circuits, analogous to classical logic gates. They manipulate qubits through unitary transformations. Some fundamental quantum gates include:
+
+- **Pauli-X Gate**: Flips the state of a qubit, analogous to a NOT gate in classical computing.
+- **Hadamard Gate**: Creates superposition, transforming a qubit from the state.
+- **CNOT Gate**: A two-qubit gate that flips the second qubit if the first qubit is in the state.
+
+## Applications of Quantum Computing
+
+### Cryptography
+
+Quantum computing poses a significant threat to classical cryptographic systems. Algorithms like Shor's algorithm can factor large numbers exponentially faster than the best-known classical algorithms, potentially breaking widely used encryption methods such as RSA. On the flip side, quantum cryptography offers new ways to secure information, such as Quantum Key Distribution (QKD), which guarantees secure communication based on the principles of quantum mechanics.
+
+### Optimization Problems
+
+Many real-world problems, such as supply chain management, financial modelling, and route optimization, involve finding the best solution among a vast number of possibilities. Quantum computing can provide significant speed-ups for solving these optimization problems using algorithms like the Quantum Approximate Optimization Algorithm (QAOA) and Grover's algorithm.
+
+### Drug Discovery
+
+Quantum computers can simulate molecular interactions at a quantum level, providing insights into the behavior of complex molecules. This capability is crucial for drug discovery and materials science, as it allows researchers to model and predict chemical reactions more accurately, potentially leading to the development of new medications and materials.
+
+### Machine Learning
+
+Quantum machine learning combines quantum computing and classical machine learning techniques to enhance data processing capabilities. Quantum computers can process large datasets and complex models more efficiently, leading to faster training times and improved performance for certain machine learning tasks.
+
+## Resources for Further Learning
+
+### Books
+1. **"Quantum Computing: A Gentle Introduction" by Eleanor Rieffel and Wolfgang Polak**
+   - A comprehensive introduction to the principles and applications of quantum computing.
+
+2. **"Quantum Computation and Quantum Information" by Michael A. Nielsen and Isaac L. Chuang**
+   - Often considered the definitive textbook on quantum computing, covering a wide range of topics in depth.
+
+### Papers
+1. **"Simulating Physics with Computers" by Richard Feynman**
+   - One of the foundational papers in quantum computing, introducing the concept of using quantum systems for simulation.
+
+2. **"Shor's Algorithm for Quantum Factoring" by Peter Shor**
+   - The seminal paper that introduced Shor's algorithm, demonstrating the potential of quantum computers to solve certain problems exponentially faster than classical computers.
+
+### Online Courses
+1. **"Quantum Computing for the Very Curious" by Michael Nielsen**
+   - A free, interactive online book that provides a hands-on introduction to quantum computing.
+
+2. **Coursera: "Quantum Computing" by University of Toronto**
+   - A comprehensive course covering the basics of quantum computing, quantum algorithms, and quantum hardware.
+
+### Tutorials and Blogs
+1. **Qiskit Tutorials**
+   - IBM's open-source quantum computing framework provides extensive tutorials and resources for learning quantum programming.
+   
+2. **Quantum Computing Report**
+   - A blog that keeps up with the latest news, developments, and insights in the field of quantum computing.
+
+By understanding these basic concepts and exploring the resources provided, you can build a strong foundation in quantum computing and appreciate its potential to revolutionize various industries.

docs/Deep Learning/Learning rule in ANN/Learning-Rules.md

@@ -0,0 +1,106 @@
+# Learning Rules in Artificial Neural Networks (ANN)
+
+## Introduction
+
+Learning rules are essential components of Artificial Neural Networks (ANNs) that govern how the network updates its weights and biases. This document focuses on two fundamental learning rules: Hebbian Learning and Adaline (Adaptive Linear Neuron) Learning.
+
+## 1. Hebbian Learning
+
+Hebbian Learning, proposed by Donald Hebb in 1949, is one of the earliest and simplest learning rules in neural networks. It is based on the principle that neurons that fire together, wire together.
+
+### Basic Principle
+
+The strength of a connection between two neurons increases if both neurons are activated simultaneously.
+
+### Mathematical Formulation
+
+For neurons $i$ and $j$ with activation values $x_i$ and $x_j$, the weight update $\Delta w_{ij}$ is given by:
+
+$$ \Delta w_{ij} = \eta x_i x_j $$
+
+Where:
+- $\Delta w_{ij}$ is the change in weight between neurons $i$ and $j$
+- $\eta$ is the learning rate
+- $x_i$ is the output of the presynaptic neuron
+- $x_j$ is the output of the postsynaptic neuron
+
+### Variations
+
+1. **Oja's Rule**: A modification of Hebbian learning that includes weight normalization:
+
+   $$\Delta w_{ij} = \eta(x_i x_j - \alpha y_j^2 w_{ij})$$
+
+   Where $y_j$ is the output of neuron $j$ and $\alpha$ is a forgetting factor.
+
+2. **Generalized Hebbian Algorithm (GHA)**: Extends Oja's rule to multiple outputs:
+
+   $$\Delta W = \eta(xy^T - \text{lower}(Wy^Ty))$$
+
+   Where $\text{lower}()$ denotes the lower triangular part of a matrix.
+
+## 2. Adaline Learning (Widrow-Hoff Learning Rule)
+
+Adaline (Adaptive Linear Neuron) Learning, developed by Bernard Widrow and Marcian Hoff in 1960, is a single-layer neural network that uses linear activation functions.
+
+### Basic Principle
+
+Adaline learning aims to minimize the mean squared error between the desired output and the actual output of the neuron.
+
+### Mathematical Formulation
+
+For an input vector $\mathbf{x}$ and desired output $d$, the weight update is given by:
+
+$$ \Delta \mathbf{w} = \eta(d - y)\mathbf{x} $$
+
+Where:
+- $\Delta \mathbf{w}$ is the change in weight vector
+- $\eta$ is the learning rate
+- $d$ is the desired output
+- $y = \mathbf{w}^T\mathbf{x}$ is the actual output
+- $\mathbf{x}$ is the input vector
+
+### Learning Process
+
+1. Initialize weights randomly
+2. For each training example:
+ 
+   a. Calculate the output:
+   
+   $y = \mathbf{w}^T\mathbf{x}$
+    
+   b. Update weights:
+   
+   $$w_{new} = w_{old} + \eta(d - y)x$$
+   
+4. Repeat step 2 until convergence or a maximum number of epochs is reached
+
+### Comparison with Perceptron Learning
+
+While similar to the perceptron learning rule, Adaline uses the actual output value for weight updates, not just the sign of the output. This allows for more precise weight adjustments.
+
+## Conclusion
+
+Both Hebbian and Adaline learning rules play crucial roles in the development of neural network theory:
+
+- Hebbian Learning provides a biological inspiration for neural learning and is fundamental in unsupervised learning scenarios.
+- Adaline Learning introduces the concept of minimizing error, which is a cornerstone of many modern learning algorithms, including backpropagation in deep neural networks.
+
+Understanding these basic learning rules provides insight into more complex learning algorithms used in deep learning and helps in appreciating the historical development of neural network theory.
+
+
+## How to Use This Repository
+
+- Clone this repository to your local machine.
+
+```bash
+  git clone https://github.com/CodeHarborHub/codeharborhub.github.io/tree/main/docs/Deep%20Learning/Learning Rule IN ANN
+```
+- For Python implementations and visualizations:
+
+1. Ensure you have Jupyter Notebook installed 
+
+```bash
+  pip install jupyter
+```
+2. Navigate to the project directory in your terminal.
+3. Open learning_rules.ipynb.

docs/Deep Learning/Learning rule in ANN/learning_rules.ipynb

@@ -0,0 +1,117 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<h3>Implementation of different activation fucntion in learning rules</h3>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Trained Weights for hebb network are :  [1.5488135  1.71518937]\n",
+      "Trained bias for hebb network are :  [1.60276338]\n",
+      "Trained Weights for hebb network are :  [0.53143536 0.57216559]\n",
+      "Trained bias for hebb network are :  [0.51141955]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Problem --> OR- Gate\n",
+    "input = np.array([[1, 1] ,[1,-1] , [-1,1] ,[-1,-1] ])\n",
+    "output = np.array([1 ,1 , 1 ,-1 ])\n",
+    "np.random.seed(0)\n",
+    "weight = np.random.rand(2)\n",
+    "bias = np.random.rand(1)\n",
+    "learning_rate = 0.1\n",
+    "\n",
+    "# Hebbian Learning rule\n",
+    "def hebbNetwork(input , output , b , w ,epoches, learning_rate = .1):\n",
+    "    for epoch in range(epoches):\n",
+    "        for i in range(len(input)):\n",
+    "            cal_output = (np.dot(input[i] , w) + b)\n",
+    "            # print(w)\n",
+    "            if cal_output != output[i]:\n",
+    "                w = w + (learning_rate*output[i]*input[i])\n",
+    "                b = b + (learning_rate* output[i])\n",
+    "    return w , b\n",
+    "\n",
+    "# Aderline Learning rule\n",
+    "def AderlineNetwork(input , output , b , w ,epoches, learning_rate = .1):\n",
+    "        for epoch in range(epoches):\n",
+    "            for i in range(len(input)):\n",
+    "                cal_output = (np.dot(input[i] , w) + b)\n",
+    "                error = (output[i] - cal_output)**2\n",
+    "                # print(error)\n",
+    "                if cal_output != output[i]:\n",
+    "                    w = w + (learning_rate*(output[i]- cal_output)*input[i])\n",
+    "                    b = b + (learning_rate*(output[i]- cal_output))\n",
+    "        return w , b\n",
+    "\n",
+    "\n",
+    "wh , bh = hebbNetwork(input , output , bias , weight , 5)\n",
+    "\n",
+    "print(\"Trained Weights for hebb network are : \" , wh)\n",
+    "print(\"Trained bias for hebb network are : \" , bh)\n",
+    "\n",
+    "wa , ba = AderlineNetwork(input , output , bias , weight , 5)\n",
+    "\n",
+    "print(\"Trained Weights for hebb network are : \" , wa)\n",
+    "print(\"Trained bias for hebb network are : \" , ba)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4.86676625]\n",
+      "[1.43638751]\n",
+      "[1.76913924]\n",
+      "[-1.66123949]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(len(input)):\n",
+    "    cal_output = (np.dot(input[i] , wh) + bh)\n",
+    "    print(cal_output)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/Flask/11-Flask app on Heroku.md

@@ -0,0 +1,50 @@
+---
+id: Deploy Python Flask App on Heroku
+title: how to deploy a flask app on Heroku
+sidebar_label: Flask App on Heroku
+sidebar_position: 11
+tags: [flask, python, heroku ]
+description: In this tutorial, you will learn about deployment offlask app on Heroku.
+---
+
+ Flask is based on the Werkzeug WSGI toolkit and Jinja2 template engine. Both are Pocco projects. This article revolves around how to deploy a flask app on Heroku. To demonstrate this, we are first going to create a sample application for a better understanding of the process. 
+
+The Prerequisites are-
+1.Python
+2.pip
+3.Heroku CLI
+4.Git
+
+### Deploying Flask App on Heroku
+
+Let’s create a simple flask application first and then it can be deployed to heroku. Create a folder named “eflask” and open the command line and cd inside the “eflask” directory. Follow the following steps to create the sample application for this tutorial.
+
+ # STEP 1 :
+  Create a virtual environment with pipenv and install Flask and Gunicorn .
+
+ # STEP 2 : 
+ Create a “Procfile” and write the following code. 
+
+ # STEP 3 :
+  Create “runtime.txt” and write the following code.
+
+ # STEP 4 : 
+ Create a folder named “app” and enter the folder
+
+ # STEP 5 : 
+ Create a python file, “main.py” and enter the sample code.
+
+ # STEP 6 :
+ Get back to the previous directory “eflask”.Create a file“wsgi.py” and insert the following code.
+
+ # STEP 7 :
+  Run the virtual environment.
+
+# STEP 8 :
+ Initialize an empty repo, add the files in the repo and commit all the changes.
+
+# STEP 9 : 
+Login to heroku CLI 
+
+# STEP 10 : 
+Push your code from local to the heroku remote.