DEV Community: Sarvesh Kesharwani

Whats the difference b/w Path and Query in FastAPI?

Sarvesh Kesharwani — Sat, 07 Jun 2025 15:39:11 +0000

Path parameters are part of the URL path and are required.
Example: /get_patient_data/1
— here, 1 is a path parameter.

Query parameters come after the ? in the URL and are **optional **by default.
Example: /sorted_patient_list?sort_by=asc
— here, sort_by=asc is a query parameter.

How does Reinforcement learning relate to CNN and RNN?

Sarvesh Kesharwani — Sat, 22 Apr 2023 08:08:44 +0000

[Image Source]

Reinforcement learning is when we teach a robot by giving it treats or stickers when it does a good job. The robot learns what to do to get the treats and tries to get as many treats as possible by doing the right things. It's like playing a game to learn how to make good choices.

CNN and RNN are like helpers for the robot. They help the robot see and understand things better. They can look at pictures and tell the robot what's in them, like a cat or a dog, or they can help the robot understand words and sentences. They are like tools to help the robot learn even more about the world around it.

Similar to how you may have seen models trained in Reinforcement learning play games like Mario or Flappy Bird to learn how to clear levels and earn as many achievement points or treats as possible.

Implementing max heap from scratch in Python!

Sarvesh Kesharwani — Sat, 18 Mar 2023 21:02:00 +0000

class MaxHeap:
    def __init__(self):
        self.heap = []

    def insert(self, val):
        self.heap.append(val)
        self._percolate_up(len(self.heap)-1)

    def extract_max(self):
        if len(self.heap) > 1:
            max_val = self.heap[0]
            self.heap[0] = self.heap.pop()
            self._percolate_down(0)
        elif len(self.heap) == 1:
            max_val = self.heap.pop()
        else:
            max_val = None
        return max_val

    def _percolate_up(self, idx):
        parent_idx = (idx - 1) // 2
        if parent_idx < 0:
            return
        if self.heap[idx] > self.heap[parent_idx]:
            self.heap[idx], self.heap[parent_idx] = self.heap[parent_idx], self.heap[idx]
            self._percolate_up(parent_idx)

    def _percolate_down(self, idx):
        child_idx1 = idx * 2 + 1
        child_idx2 = idx * 2 + 2
        max_idx = idx
        if child_idx1 < len(self.heap) and self.heap[child_idx1] > self.heap[max_idx]:
            max_idx = child_idx1
        if child_idx2 < len(self.heap) and self.heap[child_idx2] > self.heap[max_idx]:
            max_idx = child_idx2
        if max_idx != idx:
            self.heap[idx], self.heap[max_idx] = self.heap[max_idx], self.heap[idx]
            self._percolate_down(max_idx)

In the code above, we define a MaxHeap class with methods to insert elements into the heap and extract the maximum value from the heap. The _percolate_up and _percolate_down methods are used to maintain the heap property after inserting or extracting elements.

To create a new MaxHeap object and insert values into it, you can do the following:

heap = MaxHeap()
heap.insert(10)
heap.insert(30)
heap.insert(20)
heap.insert(5)

To extract the maximum value from the heap, you can call the extract_max method:

max_val = heap.extract_max()
print(max_val) # Output: 30

C# code to create a bullet and shoot it in Unity

Sarvesh Kesharwani — Fri, 17 Mar 2023 19:18:00 +0000

using UnityEngine;

public class ShootBullet : MonoBehaviour
{
    // Reference to the bullet prefab
    public GameObject bulletPrefab;

    // Speed of the bullet
    public float bulletSpeed = 10.0f;

    // Update is called once per frame
    void Update()
    {
        // Check if the player pressed the fire button (left mouse button)
        if (Input.GetButtonDown("Fire1"))
        {
            // Create a new bullet instance
            GameObject bullet = Instantiate(bulletPrefab, transform.position, Quaternion.identity);

            // Get the rigidbody component of the bullet
            Rigidbody rb = bullet.GetComponent<Rigidbody>();

            // Add force to the bullet to shoot it forward
            rb.AddForce(transform.forward * bulletSpeed, ForceMode.Impulse);
        }
    }
}

How to build an image from Dockerfile?

Sarvesh Kesharwani — Thu, 16 Mar 2023 12:50:00 +0000

To build a Docker image from a Dockerfile, you can follow these steps:

Open a terminal or command prompt and navigate to the directory where your Dockerfile is located.

Run the following command: docker build -t <image_name> .

The docker build command is used to build a Docker image, and the -t flag is used to give the image a name. The . at the end of the command tells Docker to use the current directory as the build context.

For example, if your Dockerfile is located in a directory called myapp, and you want to name the image myapp-image, you would run the following command:

docker build -t myapp-image myapp

Docker will start building the image based on the instructions in your Dockerfile. It will download any necessary dependencies and packages and execute any commands specified in the Dockerfile.

Once the build process is complete, you can verify that the image was created by running the docker images command. This will show a list of all the Docker images on your system, including the one you just built.

That's it! You have successfully built a Docker image from a Dockerfile. You can now use this image to create and run Docker containers.

Understanding Conv2d Layer with Tensorflow implementation?

Sarvesh Kesharwani — Thu, 16 Mar 2023 04:07:00 +0000

Conv2D is a type of convolutional layer commonly used in deep learning for image recognition tasks. It applies a set of filters to the input image to detect specific features and patterns.

Here's an example implementation of Conv2D layer using TensorFlow in Python:

import tensorflow as tf

# Define the input shape of the image
input_shape = (28, 28, 1)  # 28x28 grayscale image

# Define the number of filters and their size
filters = 32
kernel_size = (3, 3)

# Define the input tensor
inputs = tf.keras.Input(shape=input_shape)

# Define the Conv2D layer
x = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, activation='relu')(inputs)

# Print the output shape
print(x.shape)

In this example, we define the input shape of our image as a 28x28 grayscale image. We then define the number of filters and their size for our Conv2D layer. We create an input tensor using tf.keras.Input() and pass in the input_shape.

Next, we define the Conv2D layer using tf.keras.layers.Conv2D() and pass in the filters, kernel_size, and activation function relu. We apply this layer to the inputs tensor using functional API of TensorFlow.

Finally, we print the shape of the output tensor. The output shape of Conv2D layer will be (batch_size, height, width, filters).

Note that this is just a basic example, and in real-world applications, there may be many other parameters and layers involved in the model.

What is the venn-diagrammatic relation b/w container, venv and git_branches?

Sarvesh Kesharwani — Wed, 15 Mar 2023 13:33:04 +0000

The order of setting up these tools can vary depending on your specific project needs and workflow.

Typically, you would start by setting up Git branches to manage different versions of your codebase. Once you have set up your Git repository, you can create a Dockerfile to define the environment for your Python application, including any necessary dependencies, tools, and configurations. The Docker container can be used to provide a consistent and reproducible environment for running your Python application.

Next, you can create a Python virtual environment inside the Docker container to manage your Python dependencies. This can help ensure that your project dependencies are consistent and reproducible across different environments.

Once you have set up your Docker container and Python venv, you can start developing your code in a Git branch. You can activate the Python virtual environment and start installing any necessary project dependencies using pip. When you are ready to commit your changes, you can use Git to manage and version control your code.

Overall, the order of setting up Git branches, Docker containers, and Python venv can vary depending on your specific project needs and workflow. However, it's important to ensure that all three tools are integrated and working together to provide a consistent and reproducible development and deployment environment.

physical memory, virtual address space, size of the page table

Sarvesh Kesharwani — Wed, 15 Mar 2023 07:29:48 +0000

https://gateoverflow.in/739/gate-cse-2001-question-2-21?show=739#q739

To solve this question, you need to have a basic understanding of the following concepts of memory management:

Memory management: Memory management refers to the process of managing the memory resources of a computer system, including physical memory and virtual memory. In a virtual memory system, the memory addresses used by a program are virtual addresses, which are mapped to physical addresses by the operating system.

Paging: Paging is a memory management technique used in virtual memory systems to divide the virtual address space into fixed-size blocks called pages. Each page is mapped to a corresponding page frame in physical memory.

Page tables: A page table is a data structure used by the operating system to keep track of the mapping between virtual addresses and physical addresses. It contains information about which pages are mapped to which page frames, and it is used by the memory management unit (MMU) to translate virtual addresses to physical addresses.

Page size: The page size is the size of each page in a paging system. It is typically a power of two, and it determines the granularity of memory allocation in the system.

Relation between Docker and Kubernetes?

Sarvesh Kesharwani — Wed, 15 Mar 2023 07:23:00 +0000

Docker and Kubernetes are two complementary technologies that are often used together in modern software development and deployment.

Docker is a platform for creating and managing containers, which are a lightweight and portable way to package and distribute applications, along with their dependencies and configurations, as a single unit that can run consistently across different environments.

Kubernetes, on the other hand, is a container orchestration platform that automates the deployment, scaling, and management of containerized applications across clusters of hosts. Kubernetes provides a declarative API for managing containers, and it can run on a wide range of platforms, from local development environments to public clouds.

Docker and Kubernetes work together in the following way:

Developers use Docker to create container images that contain their applications and dependencies.

These container images are then pushed to a Docker registry, where they can be easily shared and deployed.

Operators use Kubernetes to deploy and manage these container images on a cluster of hosts, using Kubernetes' declarative API and its built-in features for scaling, load balancing, and self-healing.

Kubernetes can also manage the configuration, secrets, and networking of the containers, as well as monitor their health and performance.

In summary, Docker and Kubernetes are two complementary technologies that work together to enable modern software development and deployment. Docker provides a way to create and manage containers, while Kubernetes provides a way to automate the deployment and management of containerized applications across clusters of hosts.

What is container orchestration platform?

Sarvesh Kesharwani — Wed, 15 Mar 2023 07:22:00 +0000

A container orchestration platform is a tool or framework that automates the deployment, scaling, and management of containerized applications across a cluster of hosts. Container orchestration platforms provide a set of APIs, tools, and services that enable developers and operators to manage containers at scale, while ensuring high availability, scalability, and reliability.

Container orchestration platforms are designed to address the challenges of managing large and complex container deployments, which can involve thousands or even tens of thousands of containers running on multiple hosts or cloud instances. Container orchestration platforms provide features such as:

Container deployment and scaling: The ability to deploy containers across multiple hosts or cloud instances, and to scale containers up or down based on demand.

Load balancing: The ability to distribute traffic across containers, and to automatically route traffic to healthy containers.

Service discovery: The ability to automatically discover and manage the network addresses of containers, and to route traffic to the appropriate container based on service name or label.

Container health monitoring and self-healing: The ability to monitor the health and performance of containers, and to automatically restart or replace containers that are unhealthy or failing.

Configuration and secret management: The ability to manage the configuration and secrets of containers, and to update them automatically when needed.

Some popular container orchestration platforms include Kubernetes, Docker Swarm, Mesos, and Nomad. These platforms provide a powerful set of tools and services for managing containers at scale, and are widely used in modern software development and deployment.

keras.applications .preprocess_input(x) to preprocess the input image for Neural Network.

Sarvesh Kesharwani — Wed, 15 Mar 2023 07:00:39 +0000

preprocess_input(x) is a function that applies some preprocessing to an input image before feeding it to a neural network model. It is part of the keras.applications module and is typically used when working with pre-trained models such as ResNet50.

The preprocess_input function takes a single argument x, which is a NumPy array representing an image. The function applies a series of transformations to the image, such as normalizing the pixel values to be between -1 and 1 and zero-centering the data.

The purpose of this preprocessing step is to ensure that the input image is in the same format as the images used to train the pre-trained model. This is important because the pre-trained model has learned to recognize patterns in images of a specific format, and if the input images are not in that format, the model's performance may suffer.

Once the input image has been preprocessed, it can be passed through the neural network model to obtain a prediction.

What is a batch in the context of neural networks?

Sarvesh Kesharwani — Wed, 15 Mar 2023 06:55:43 +0000

In machine learning, a batch refers to a subset of the training data that is processed at once during the training process. Instead of processing the entire dataset in one go, it is often more efficient to break it down into smaller batches and feed them into the model sequentially. This allows the model to update its parameters more frequently, which can help it converge to a better solution faster.

For example, if you have a training set of 1000 examples, you might choose to process it in batches of 100. This means that the model will see the data in 10 passes, with each pass updating its parameters based on the loss calculated for the 100 examples in that batch. The size of the batch is a hyperparameter that can be tuned to find the optimal balance between training time and performance.