Forem: Priya Srivastava

Unveiling the Hype: What Are Vector Databases and Why They're the Talk of the Town!

Priya Srivastava — Wed, 14 Jun 2023 15:46:23 +0000

Vector databases provide the backbone for the effective functioning of generative AI and LLMs by facilitating seamless access to and retrieval of similar data representations. By organizing and indexing vectors, vector databases provide the foundation for these advanced AI models to generate more accurate and contextually relevant outputs, making them an essential component in the world of generative AI and LLMs.

What Are Vector Databases? Let's Get Nerdy!

Alright, let's break it down. Vector databases are like the superheroes of data management. They don their capes, equipped with advanced indexing and searching techniques, to tackle the ever-growing challenges of storing and retrieving information. Think of them as the Avengers of the data world, ready to save the day!

The Power of Vector Similarity Search: Finding Your Data Soulmates!

Now, imagine you're on an online shopping spree. You find the perfect pair of shoes, and you want more options just like them. Enter vector databases! These databases excel at finding data points that are similar to your query vector. They're like your shopping soulmates, helping you discover products that match your preferences and enhancing your retail therapy experience.

But wait, there's more! Vector databases can also work wonders in image recognition. They're like the Sherlock Holmes of databases, instantly identifying similar images or objects.

Need to find a photo of that hilarious cat you saw? Boom! The vector database will have it at your fingertips faster than you can say "meow."

Vectorization: Turning Data into Supercharged Vectors!

Now, let's talk about vectorization, the secret sauce that makes vector databases so powerful. It's like giving your data a superhero makeover! Vectorization involves transforming raw data into high-dimensional vectors that capture all the relevant features and relationships. It's like taking your everyday Clark Kent data and turning it into the Superman of vectors!

How Do Vector Databases Work? The Secret Sauce Revealed!

Behind the scenes, vector databases rely on some serious technical wizardry. So, let's put on our data scientist hats and unravel the magic!

Step 1: Vectorization - From Ordinary to Extraordinary!

The journey begins with vectorization, where raw data is transformed into high-dimensional vectors. It's like giving your data a superhero makeover—putting on the spandex and cape to become a mighty vector!

Step 2: Indexing - Organizing the Vector Avengers!

Once the data is transformed into vectors, it's time to assemble the Vector Avengers—the indexing algorithms. These algorithms work tirelessly to organize the vectors in a way that enables efficient searching and retrieval. Think of them as the Hulk of organization, smashing through data chaos to bring order to the database universe!

Step 3: Similarity Search - Finding Your Vector Soulmates!

Now comes the fun part—similarity search! When you make a query, the vector database springs into action, comparing your query vector to the vectors stored in its mighty index. It's like a cosmic game of "Find the Most Similar Vector." The database quickly identifies the closest matches, bringing you one step closer to finding your data soulmates!

Step 4: Ranking and Retrieval - Unleashing the Power of Order!

Once the similar vectors are found, the vector database sorts them in order of relevance. It's like having a ranking system that separates the Avengers from the sidekicks, ensuring that the most pertinent data is presented to you. With a snap of its metaphorical fingers, the database retrieves the top-ranked results, giving you the data you need, when you need it!

Real-World Applications: Where Vector Databases Shine!

Okay, let's see these vector databases in action, shall we?

Recommendation Systems: Picture this: You're binge-watching your favorite show, and suddenly, a recommendation pops up that perfectly matches your taste. Thanks to vector databases, personalized recommendations make streaming services feel like they have psychic powers. It's like they can read your mind (or your vectors)!
Image and Video Analysis: Imagine you're scrolling through an endless feed of images, trying to find that one elusive picture you saw last week. With vector databases, image searches become a breeze. They're like your personal detective, helping you find that lost picture faster than you can say "cheese."
Fraud Detection: Let's face it, fraudsters are the villains of the financial world. But fear not! Vector databases are here to save the day. By analyzing patterns in transactions and comparing vectors, they can spot those sneaky anomalies and detect fraud faster than you can say "gotcha."
Biomedical Research: Vector databases are also heroes in the world of healthcare. They assist researchers in analyzing genomics data, protein structures, and drug discovery. It's like having a team of brilliant scientists by your side, working tirelessly to advance medical breakthroughs.

Future Prospects: A Thrilling Data-Driven Tomorrow!

Hold onto your hats because the future of vector databases is full of excitement! As research progresses, we can expect even more powerful vectorization techniques and lightning-fast indexing algorithms. The adoption of vector databases will skyrocket, leading to mind-blowing advancements in data analytics and artificial intelligence. It's like a superhero team-up that will reshape the future of technology!

Conclusion

Vector databases have ushered in a new era of data management, allowing us to unlock valuable insights from complex datasets efficiently. By harnessing the power of vector similarity search and leveraging advanced vectorization techniques, these databases have revolutionized the way we store, retrieve, and analyze data. As we continue to explore the vast potential of vector databases, we can anticipate groundbreaking advancements that will shape the future of data-driven decision-making across industries. So, go forth, unleash the power of vectors, and embrace the extraordinary potential of data!

My Journey with React States: Common Mistakes I Made and How I Overcame Them

Priya Srivastava — Sat, 10 Jun 2023 15:44:11 +0000

Throughout my journey with React and its state management, I encountered some common mistakes that many beginners, including myself, often make. However, I learned valuable lessons from these experiences and discovered effective solutions to overcome these challenges.

Introduction to States in React:
In React, states are a crucial part of managing data within a component. They allow us to store and update values that can affect the rendering of our components. With the introduction of React hooks, specifically the useState hook, managing states has become much easier. Let's explore some common problems beginners may encounter when working with states in React.

Problem 1: Incorrectly Updating the State:
Suppose we have an h1 tag that displays a number, and we want to increase that number whenever a button is clicked. We can achieve this using the useState hook. However, a common mistake is to directly update the state value without considering its previous state.

import React, { useState } from 'react';

function Counter() {
  const [number, setNumber] = useState(0);

  const increaseNumber = () => {
    // Incorrect way: directly updating the state
    setNumber(number + 1);
  };

  return (
    <div>
      <h1>{number}</h1>
      <button onClick={increaseNumber}>Increase</button>
    </div>
  );
}

The problem with the above code is that React batches state updates, and when we update the state using the setNumber function, it may not reflect the latest value of number. To solve this, we should use the functional update approach:

const increaseNumber = () => {
  // Correct way: using functional update
  setNumber((prevNumber) => prevNumber + 1);
};

By passing a function to setNumber, we ensure that we are updating the state based on the previous value. This guarantees that we are working with the latest state and avoiding unexpected behavior.

Problem 2: Handling Initialization:
Another mistake I stumbled upon was the initialization of states. Initially, I faced the dreaded "white screen" issue when trying to access properties of an undefined object.

Let's consider an example where we have a user state that should contain properties like name, email, and images. However, initially, we don't have this data, and accessing undefined properties can lead to errors.

const [user, setUser] = useState({});

// Trying to access undefined properties
return (
  <div>
    <span>Username: {user.name}</span>
    <span>Email: {user.email}</span>
    <span>Profile Picture: {user.images[0]}</span>
  </div>
);

To avoid such errors, it's recommended to initialize the state with the expected type. For example, if the user is an object, we can initialize it as an empty object:

const [user, setUser] = useState({ name: '', email: '', images: [] });

By providing initial values for the expected properties, we prevent the component from breaking when trying to access them before they are updated.

Problem 3: Updating a Specific Object Property:
Suppose we have a user object with properties like name, email, and images, and we want to update only the name property based on user input. We may attempt to directly update the property, but this approach won't work.

const changeUser = () => {
  // Incorrect way: not updating the property correctly
  setUser({ name: input });
};

Instead, we should update the desired property while preserving the other properties using the spread operator:

const changeUser = () => {
  // Correct way: updating the property using spread operator
  setUser((prevUser) => ({ ...prevUser

, name: input }));
};

By spreading the previous state object prevUser and modifying the specific property, we ensure that only the desired property is updated while keeping the rest unchanged.

Problem 4: useState vs. useReducer:
The useState hook is suitable for most state management needs, but for more complex cases involving nested objects, arrays, and multiple property updates, the useReducer hook provides a better approach. Suppose we have a complex form where multiple inputs need to be managed and validated.

In such scenarios, using useReducer with separate actions and a reducer function can improve the organization and scalability of our state management. Although it involves more code, it provides better control over state transitions and reduces potential errors.

Problem 5: Correctly Deriving States:
Suppose we have an array of items and want to store the selected item in the state. A common mistake is storing the entire object in the state, which can lead to inconsistencies if the source array changes. Instead, we should store an identifier (e.g., the item's ID) and retrieve the corresponding object from the array when needed.

const [selectedItemId, setSelectedItemId] = useState('');

const selectItem = (itemId) => {
  // Incorrect way: storing the entire object
  setSelectedItemId(itemId);
};

// Correct way: retrieving the object using the ID
const selectedItem = items.find((item) => item.id === selectedItemId);

By storing only the identifier and deriving the desired object from the array when necessary, we ensure that the derived state remains synchronized with the source state.

Conclusion:
In conclusion, my journey with React states has been filled with valuable lessons. By addressing the mistakes I made and implementing the appropriate solutions, I gained a deeper understanding of state management in React. These experiences have not only improved my coding skills but also taught me the importance of careful consideration when working with states. I hope that by sharing my personal experiences, other beginners can learn from these mistakes and navigate their own React projects more effectively. Remember, making mistakes is a part of the learning process, and overcoming them leads to growth and mastery.

290. Word Pattern Leetcode Problem of The Day- 01 Jan 2023

Priya Srivastava — Sun, 01 Jan 2023 16:49:21 +0000

Hello everyone! It is New year's first day and I have decided to document the questions I solve on Leetcode. This is to keep a record of my thought process of approaching questions and also to document my solutions in an organised manner.
If you are reading this, hope the blog helps you as well. So here is how I approached the first question of Leetcode daily challenge.

Question link:

Given a pattern and a string s, find if s follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in s.

Example 1:
Input: pattern = "abba", s = "dog cat cat dog"
Output: true

Intuition

The problem states there are 2 strings and all I have to do is compare them such that every character of 'pattern' corresponds to the 'word' of String 's'.

eg:
a -> dog
b -> cat
b -> cat
a -> dog
(And vice versa)
This statements brings us to the idea that we can use a hashmap to store word and character as key and value.

Approach

All we need to do is map the word of s to the char of pattern and vice versa. Check if they correspond to the same thing using .equals()
Base case: the length of pattern and number of words in s should be same.

Now code this!

How will I get the word? By using .split(" ")

Complexity

Time complexity:

O(n)
Space complexity:

O(n)

Code

class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] word = s.split(" ");
        if(word.length != pattern.length()) return false;
        HashMap<Character, String> map1 = new HashMap<>();
        HashMap<String, Character> map2 = new HashMap<>();
        for(int i=0; i<pattern.length(); i++) {
            char c = pattern.charAt(i);
            String w = word[i];
            if(!map1.containsKey(c)){
                map1.put(c, w);
            }
            if(!map2.containsKey(w)) {
                map2.put(w, c);
            }
            if( (!map1.get(c).equals(w)) || (!map2.get(w).equals(c)) )
                return false;
        }
        return true;
    }
}

Essential Linux Commands for beginners

Priya Srivastava — Wed, 21 Dec 2022 05:46:33 +0000

To anyone getting started with Linux, check out these commands and make your life easier!

List (ls)

Use the ls command to display the files, along with all their properties, are in a directory.

Change directory (cd)

It is often necessary to change directories. That’s the cd command's function. For instance, this example takes you from your home directory into the Desktop directory:

$ **cd** Desktop

To get back to the previous directory use:

$ **cd** ..

Print working directory (pwd)

The pwd command prints your working directory. In other words, it outputs the path of the directory you are currently working in.

Make directory (mkdir)

Making directories is easy with the mkdir command. The following command creates a directory called newfolder unless newfolder already exists:

$ **mkdir** newfolder

Copy a file (cp)

Copy files from-here *to-there *with the cp command. Here's an example to copy from file1.txt to file2.txt:

$ **cp** file1.txt file2.txt

Create an empty file (touch)

Easily create an empty file with the touch command:

$ **touch** newfile.txt

Escalate privileges (sudo)

The sudo (or super user do) command comes in when you require super user permissions (root) while administering your system. When you're trying to do something and your computer alerts you that only an administrator (or root) user can do, stating Permission denied, just preface it with the command sudo:

$ **touch** **/**etc**/**os-release **&&** **echo** "Success"
touch: cannot **touch** '/etc/os-release': Permission denied

$ **sudo** **touch** **/**etc**/**os-release **&&** **echo** "Success"
Success

Read the manual (man)

The single most important command that you will need to get the documentation for each of the commands on your Linux system is man .For instance, to read more about mkdir:

$ **man** **mkdir**

Another similar command is info.

Use these commands and keep learning and exploring! Thank you for reading this post, stay tuned for my next blog posts.
You can find me on Twitter, LinkedIn and Github.✨

Adobe India Women In Tech (WIT) Scholarship 2021 Essay and interview Experience

Priya Srivastava — Wed, 21 Dec 2022 05:38:10 +0000

The Adobe WIT scholarship is a scholarship opportunity for pre-final year femal students in a formal technology 4-year BE / B.Tech education program or an Integrated ME/MS/MTech program at an Indian University or Institute at the time of applying. Should be pursuing a Major or Minor in the following streams: Computer Science/Engineering, Information Science, Data Science, Electrical/Electronics Engineering, Math, and Computing. Source: Adobe WIT India official page.

It comprises of essays and interview as its two rounds of process.

Adobe India Women-in-Technology Scholarship

Essay experience:

The essay questions consist of questions on your inspiration to join tech, your interests, any challenges you have faced or anticipate facing, your role models etc. Some things to keep in mind while preparing the essay are:

Make your first draft without any filters, write everything you think about the given topic and express it in the most honest way possible. At this stage you should not be thinking about the word limit. From my experience: Don’t try to write things that you think the selectors might want to hear, don’t mould your thoughts to match some standards, write your story.
Remember, essays are for the selection committee to know you, so make sure you do a good job telling about yourself. What inspires you? Why technology? Ask yourself such questions and answer for yourself.
Now that you have your draft ready, it is time for editing! Check for grammar, spelling errors. Don’t go for advance english and complicated words. Try to point out important lines and points and then trimming down your draft to match the word limit. You wrote everything you could write on the topic, your mind is very clear so you know how to shorten it down to a crisp, beautiful essay ;)

Tip: You can include a short video about yourself focusing on your interests, achievements and why do you deserve the scholarship.

Some reviews I received and shared were:

State the fact with supporting examples like I did this, built this using this tech etc.
Include why you chose engineering, tech you are working on right now, what do you want to do after graduation. For example, was it your childhood dream to be an engineer or someone inspired you. These days what tech do you feel I want to build if I had all the neccessary knowledge.
Ask yourself these questions, you’ll then be able to answer the essay honestly.
Also I recommend get someone else also reveiw your essays and resume, better to seek more inputs.

Don’t sound very generic. Write things about yourself so that they get to know you as a person for eg. everyone applying is hard working, you need not mention it specifically, a better way to put it however can be a story from your life. Maybe take your JEE preparation as an example, tell them about how you spent time, faced challenges and then got into your college. That story makes you unique, you get the idea?

Interview Experience:

I received interview invitation after my essay submissions. The interview was set up on 2 November 2021 with a technology specialist from Adobe. The interview was conducted on MS Teams by one of Adobe’s Research scientist.

My interview was more focused towards my projects and the tech stack I used. I shared my screen to show the hosted projects. I explained my inspiration for building the projects and the challenges I faced in the process. Other questions were based on the technical questions on the tech stack I mentioned. How will you implement a particular feature… and similar questions. Another question- what is the future plans for my projects?

You can cover your work experience, project and your interests for your introduction. PS: This is your first impression so prepare well.
Know well about your projects. Why and what of the technology. Why did you build the project are some questions you can expect.
Prepare behavioural questions and also know your essay very well. You can keep a printout of your resume and essay for your reference.
Be confident and own your accomplishments. Don’t take it as something to fear about. The interview is just a conversation about your interests and how well do you know about the skills you mentioned.
Ask questions at the end of interview. Use this chance wisely. You could talk about your interests, work culture of the company, any research activities or innovations etc. You can take a look at the LinkedIn profile of your interviewer and discuss about their expertise. For eg. my interviewer was into ML, so we had a good discussion on the same at the end of the interview.

Though I didn’t ultimately receive the scholarship, I feel extremely grateful to have made it this far in the Adobe WIT scholarship. I will definitely keep developing my technical skills and knowledge. There is no substitute for knowing technology at a deeper level.

To all the young women in tech reading this, I encourage you to keep pushing your boundaries and doing wonderful work in the technology space. Keep applying, be proud of your achievements and apply to all the opportunities you get. Feel free to reach me on Twitter @ shivikapriya for any queries. Happy to help 😄🤝

Like this post? Like and share this article with your friends.

Demystifying Git and GitHub

Priya Srivastava — Sun, 06 Dec 2020 06:33:45 +0000

If you are new to software development and have wondered what git and Github essentially mean, then you are at the right place! As a developer, you will encounter these two terms quite frequently and use them too! Get an answer to what git and Github are, why would you need them, and are they different? 🤔

Putting things Simply👀

Let us assume that you have built a calculator that can add and subtract numbers, you show it to your friend and he says, “That’s great! How about adding some more features to it like multiplication and division?” So what you can do is you can PUSH the implementation of the calculator, i.e., its code, on a hosting platform using ‘some tool’. On that platform, your friend can collaborate on the project and can introduce the code for multiplication or division. Using the tool again, you add the newly introduced code for multiplication or division. This will now be a new version of the calculator- the one with more features! So what hosting platform did you use here?** It is GITHUB- a website, a hosting service for your project.** Interestingly your project can now be called an Open Source project, or a Github repository!

Imagine that the multiplication feature is not working properly for decimal numbers and you want to get back to your previous calculator version. Is this possible? Yes, it is possible, using ‘the tool’ you’ve been using till now. The tool is called GIT- a version control system. It can allow you to get back to the previous version of your project, something like the undo button in MS Word!

So GIT is installed in your local system whereas GITHUB is a hosting service- a website where you can share your project with others, giving them the power to make revisions or edits.

Now that you know what git and GitHub are, you can go ahead and build some cool projects and collaborate with the projects of other programmers as well!👩‍💻

So if you haven't already, then get a Github account, install git and get into some real action! May the source be with you!🌞

Feel free to reach me on Twitter @ shivikapriya for any queries. Happy to help 😄🤝

Data Structure and Algorithms: Linear Search

Priya Srivastava — Wed, 18 Nov 2020 17:16:59 +0000

What is Searching?

In Computer Science, searching is "the process of finding an item with specified properties from a collection of items." An item can be anything from a stored record or an array element to elements of other search spaces.

But why do we need Searching?

The answer is- to find the data that you are looking for, from a large set of data. For example, finding your friend's phone number from a long contact list can be made easier using searching algorithms. Here the contact list is the collection of items and your friend's number is the data with the specified property.

Some examples of searching algorithms are Linear Search, Binary Search, Interpolation Search, etc. Here we'll discuss Linear Search.

What is Linear Search?

Linear search is a simple searching algorithm that checks every item in a collection sequentially. If the match is found the item is returned, otherwise the search continues till the end of the collection.
Assume that you are given an array where the order of the elements is not known. In this case, you'll have to scan through each element of the array to find the element with the specified property.

The Algorithm can be written like this:

Given an Array Arr and Item to be found data.
Check the first element. If it is equal to data, return position of the first element. Else check for the next element.
Check until the last element is compared.
If data not found in the array, return -1.
This type of linear Search is called Unordered Linear Search

public int unorderedLinearSearch(int[] Arr, int data)
{
    for(int i=0; i<Arr.length; i++){
        if (Arr[i] == data)
            return i;
} 
    return -1;
}

Time Complexity: O(n), in the worst case we scan the complete array.
Space Complexity: O(1)

Now, if the array Arr is sorted, i.e. we know the order of elements, we can perform the search as follows:

This case is called Ordered Linear Search

public int orderedLinearSearch(int[] Arr, int data)
{
    for(int i=0; i<Arr.length; i++){
        if (Arr[i] == data)
            return i;
        else if(Arr[i] > data)
             return -1;
} 
    return -1;
}

We can further optimize the time complexity for the cases when data is:

at the last position in the array from O(n) to O(1) or,
not present in the array, from O(n) to O(n/2) by checking elements from left and right positions.

public int optimiseLinearSearch(int[] Arr, int data)
{
    int left = 0; 
    int length = Arr.length; 
    int right = length - 1; 
    int position = -1; 

    for (left = 0; left <= right;){

         if (Arr[left] == search_Element)  
            { 
                position = left; 
                System.out.println(position); 
                break; 
            } 

         if (Arr[right] == search_Element)  
            { 
                position = right; 
                System.out.println(position); 
                break; 
            } 

            left++; 
            right--; 
     } 
        if (position == -1) 
            System.out.println("data not found"); 
    } 
}

Congratulations! Now you know what Searching Algorithms are and how the Linear Search algorithm is implemented.

In the next blog, we'll be looking at a few more concepts of Data Structures and Algorithms!

Connect with me
Twitter
LinkedIn

Thank You for Reading!😃