DEV Community: Mizuno Sutoiko

🌊 How to navigate a monotonous Job?

Mizuno Sutoiko — Mon, 14 Oct 2024 23:44:39 +0000

Be like water my friend.
Bruce Lee

How great it would be if everyone have a meaningful job, something that we truly like, with a good enough pay, and doing things that solve real world problems, or at least problems of our interest.

Most of us will have undoubtedly boring, simple, or pointless jobs. The professionals that end up doing what they studied for are scarce, and ultimately if they get a job on their area of interest, it would be a job with a lower pay, doing the boring things that their more senior peers don't want to do, or things that only benefit a few people.

This post is an analysis of some options to consider if we are not where we want to be, the options are:

Adapt.
Have a side project.
Merge your purpose with your job.
Change jobs.

Let's check them!

Adapt

A boring job that pay the bills is a great job, since it is not as sexy, there would be fewer people studying to work on the same thing, you'll have less competence, and if it's easy, you'll excel doing some simple things, there are not many cons of that job.

Society needs this monotony to work as it works today, most boring jobs are necessary and the fact that you are doing them means that you are contributing to something bigger than yourself.

You may not be living to your fully potential, you may not be working on something that interest you, and you may not be happy in the long run when you look back and that job was the only thing that you did for the past 10 years.

But these kind of jobs could be what you need to support a family, yourself, to have more free time, and to gain the financial security for the other things that matter the most to you.

Flowing and adapting to a boring job requires a lot of resilience and discipline, and ultimately, when you become too good at something, either you start again in something that you don't know how to do, or you adapt to the predictability of the job where you gained such mastery.

To be happy and fulfill you just have to be grateful with what you have and what you've done, probably you'll still remember your job, if you are mindful at it.

Have a side project

It will be hard, it will require additional time, and it could lead to nowhere, but doing something that you enjoy will give you a feeling that otherwise would be difficult to get, and that's enough.

If the side project is focused on a skill that you want to improve, if it could give you additional money in the future, or if you are helping someone while doing so, it is a great plus.

You may be wondering if this could make your days easier or calmer in the future, don't think so. It is possible that you end up working a lot more, making your life unbalanced, sacrificing your free time, and being exhaust at nights, you can sort this out by being organized and having good habits, but it will be hard still.

The good thing is that even if you are working more and unbalancing your life, you'll look back and have something to remember, lessons, failures, hard nights, dummy projects and bad decisions, but something to remember anyways.

Focusing on a side project where you do few things you like or want may be great to remember your days more and build something in the long run, you can use your vacations to work on it deeply.

Merge your purpose with your job

If you decided to have a side project, or improve your skills outside of work, you could be a bit sparse hoping to get out of the office so you could work on your purpose, this is a good signal, you are enjoying it, but most of the day you are still working.

One awesome alternative is to look for ways to apply your recently acquired knowledge, or skills of the project you were doing into your current job. For example, if your project is about looking for duplicate images in your Phone photos, you could end up using a Dhash or something related to drop similar images, that knowledge could be useful for a project at work.

Another example could be that your project is about writing a blog, writing skills are really useful to interact with colleages, make documentation for your repos, or presenting new ideas to customers.

By merging both, you make your job more exciting bit by bit, however, if the two things are totally unrelated, your boss is close minded, or your team doesn't endorse your new contributions, you can try the last option.

Change jobs

I put this one as the last option, since the process of changing companies or teams, and starting all over again could be challenging, but if you feel that the current place where you are isn't aligned with your long-term goals, you tried to adapt but still there are plenty of things that you want to improve in your team, or you see that there are much better opportunities somewhere else, this would be a nice option to consider.

It has a great luck factor on it that you can diminish if you know:

The projects that you're going to be working on.
Your teammates attitude and enjoyment of the day-to-day work.
The growth roadmap.
The necessary skillset.

With that info you can be sure of what to expect at the new team/company that you choose, and if that is your own company as a result of a successful side project, those questions could be great to answer to create a great company culture.

Since this is the harder and more risky choice, you'll never be sure of what to expect, but if you arrive to a monotonous job again, you can read this article one more time 😅.

A good signal is that after making the choice you feel a lot better everyday, and you are eager to learn new things at the new place, this is awesome and I hope that this happens to you.

Cross tips

Talk about it

You can talk about the monotony of your job with someone, usually other people have monotonous jobs too, so you could support each other, give advice, or simply express how you feel.

Writing about it could be great too!

Create good habits

Good habits will give you the energy to tackle a side project or your main work, that's a fact.

A small exercise routine everyday, active pauses, reading, sleeping for at least 8 hours, eating less sugar and going outside are good habits that could improve how we feel during the day.

Also, having an hour to start working, and an hour to stop working is essential to maintain a good pace.

There are other good habits and tips that can be found in the Atomic Habits Book.

Navigate with someone else

Navigating a monotonous project could seem like being in calm waters, but in reality there is a lot of turbulence, specially in our minds.

It is easier to lost focus, to feel unproductive, and to stop working altogether due to a lack of motivation, so you'll look like a kid in a small pool, but your mind would be like the cover image of the post!

One way to calm down is: anything that you choose to do from the above list, do it with someone else.

If you want to adapt to the current project, if you want to have a side project, if you want to merge your purpose with your job, or if you want to change jobs, do that while sharing the decisions or the results with someone else.

A fellow navigator could be helpful to work asynchronously, to make difficult decisions, to help with parts of the project that you don't know how to do yet, so if you can, don't do it alone.

Even if you don't talk about work at all, simply doing plans with friends or hanging out with coworkers will do the trick, you may still have the same problems, but sharing experiences makes the trip a lot easier.

Don't forget to have fun! ⛵🌟

Vector Search pt. 3 - Retrieval Systems 🌌

Mizuno Sutoiko — Sat, 06 Jul 2024 17:16:15 +0000

If we try to remember, or retrieve something from our memory, we have to navigate the neural circuits in our brains in order to come up with the thing that we were trying to remember.

Our neurons activate in multiple established patterns that brings us a concept, if that concept is close to the thing that we want to remember we keep it, if not, we discard it and came up with another thing.

Here a particular thing that kind of align with this article is the difference on remembering things when we are focused or relaxed. When we are focused, we tend to narrow a lot the things in our remembering space, if we are relaxed, we have a broader remembering space, maybe take more time to remember something, but it is more probable to retrieve it at the end.

The thing is that there are some algorithms that use similar approaches to retrieve things that are close to the one that we are looking for.

Those algorithms are the Vector Retrieval Algorithms, they are at the heart of multiple search engines, ranking results based on similarity.

Here we'll try to explain them a bit.

Search Indexes

Search Indexes could be treated as a sorting algorithm for Vectors, they sort based on the similarity with respect to the input Vector.

So this algorithm will receive an input Vector, then it will compute the similarity between it and others, and finally it will return the identifiers of most similar vectors, as simple as that.

An algorithm that will compute the similarity between the input vector and all the other ones in the Database is called a Brute Force algorithm, as it compute similarity to all vectors, then sort them.

There are other algorithms that make this process a bit (or a lot) more complex, those are very sophisticated algorithms which could be better approaches than brute-force (most of the time).

Great examples of those algorithms are IVF (Inverted File), and HNSW (Hierarchical Navigable Small World)

To understand this better, I'll be using a similar metaphor to the one introduced in the HuggingFace Computer Vision Course.

IVF based algorithms

This kind of algorithm tries to breakdown the Vector Space in Cells, each cell will have a centroid, and that centroid is calculated using only the Vectors inside that cell.

So imagine that you have a lot of puzzle pieces in the floor, they could be of the same puzzle or they could be from different ones. The goal for you is to find a piece that you need (maybe for solving another puzzle), and you'll look up for it using this IVF based algorithm.

In contrast to brute Force where the puzzle pieces are sparse in the floor, and you go piece by piece checking wether it is useful to you or not, the IVF based algorithm organizes the pieces in groups based on the similarity between them, and compute a centroid piece that you can use to check wether that group of pieces could be useful or not.

At search time, we check if a centroid piece or multiple centroid pieces are somewhat similar to what we are looking for, then after finding most similar centroid pieces, we start looking for the piece that we need inside its group, so instead of searching piece by piece, we'll be searching just in the groups where the centroid piece is most similar to the piece that we have in mind.

This method is very fast, and depending on the number of centroid pieces and comparisons performed at search time (we could check inside one or multiple groups), we could have high precisions when searching for pieces.

Remember that the similarity between pieces is calculated using the features previously extracted, those features could be based on the form, image of the piece, color, size, etc... And they are all saved in a vector form (embedding).

HNSW based algorithms

These algorithms are very precise when retrieving the similar pieces. They organize the pieces in a graph-like form making them faster than brute force, and almost as precise when searching.

The below explanation will combine the puzzle metaphor with this detailed article on HNSW algorihms

The HNSW algorithm would be like having multiple levels of the puzzle pieces. Originally you'll have all the pieces organized in a way that similar pieces are connected by strings little strings (I could not come out with a better methaphor 😅) so the pieces and the strings form something like a graph, but the magic of this algorithm comes from having layers of strings.

Imagine that the string's layer could be defined by the diameter of the string (or its color), so there are pieces that have strings of multiple diameters.

When you are looking for a puzzle piece you could start anywhere in that pieces and strings mesh, but you'll start looking just at the pieces connected with the thicker strings, after finding the most similar piece connected to the thicker strings, you'll start to look for the next thiner group of string connected pieces, that were connected to that most similar piece with the tickest string, and you continue doing this process until you have looked up in all the string's thick levels, or you've find a good enough piece.

This process is more slow and requiers more memory than the IVF process, and it also consume more memory than the brute force algorithm, because this algorithm have to save all those strings (edges) that connect the pieces (vectors of features), but the results are more precise than the IVF algorithm, and faster than the brute force algorithm.

Conclusion

Having the fundamentals of what is a feature, how to extract Image based features, and how can we lookup for things in a very efficient way, we can now understand how the retreival systems of Google, Netflix, Youtube, Pinterest, and our brains (not so much) work in general.

The full process would be something like:

Adding the Vectors to the database:
Extracting the Features of the thing to search:
Performing the search using a Vector Retrieval algorithm:

And that's it!☀️

All the articles have links and materials to keep deepeing our knowledge and as the HNSW algorithms explained here that way we'll have more puzzle pieces to retrieve knowledge from, and being better developers.

I hope you've learned something from this short and sparse series. And if you have suggestions or corrections, let me know.

Happy coding! 😎

Vector Search pt. 2 - Vision Algorithms 🎑

Mizuno Sutoiko — Tue, 21 May 2024 23:57:26 +0000

If we want to add thousands of items with their respective vectors to a table, do we have to think and input these similarities one by one? 😓

There are some algorithms that convert things from the real world, to vectors in a multidimensional space, for example, if i pass the image of a King, the algorithm will convert that image to a point in a space with numeric coordinates. These types of algorithms are called Feature Extractors, and could extract the vectors from Images, Texts, Voices, and more.

The algorithms that could be used to understand the world could be Vision Algorithms, text Algorithms, sound algorithms, and Multimodal Algorithms.

Here we'll review the concept of Vision Algorithms, and hopefully in other articles we'll review the other types, also there will be some references to algorithms that you can explore and use for your own projects.

To make things a bit more intuitive we'll try to explain how ourselves as humans understand the world based on features.

How we get the features of the world? 🌍

The world is a place full of sounds, colors, textures, flavors, as other sensations, and we have multiple ways of sensing it, we use our eyes, ears, tongue, skin, nose, and brain.

Our senses collect the information about the world, our brain interpret that information by doing a mental map and matching that map with previous learned maps, these maps are wired in us, in our neurons.

For example, each time we hear a dog barking, we match that sound to the concept of dog, and we could visualize the dog, or even remember how a dog smells.

But the most interesting part is that those mental maps could be shared among things that we don't fully know, giving us the ability to generalize to a lot of things.

For example, if we see a picture of a Wolf or hear it howling, we can undestand that those signals come from a wolf, even if we just watched them from the TV.

Since Wolfs and Dogs look similar to us but are not the same, we could infer that the neural circuit of both concepts is very similar, but due to a small difference in the neuron activations, our brains know that they are not fully the same things.

This special feature of our brains allows us to infer that wolfs could bite, run very fast, and like meat, just like dogs.

So given this ability of us, one could ask the question:
Could this process be replicated by a computer?

If it is possible, we could make a computer understand that a dog and a wolf are similar concepts, just by using words, sounds, or images!

Vision Algorithms 📷

To make computers understand Image Data, we came up with this fascinate set of algorithms called Vision Algorithms. Classically they were used to detect borders, corners, letters, color histograms, etc, but these days they are used to a broad range of applications thanks to DeepLearning.

The multiple types of vision algorithms usually work with a Camera as the Sensor, and the algorithm will look for shapes, colors, or textures, patterns in general to understand the captured image.

The camera would be like the Eyes of the system, and the algorithm would be like the brain, it will match the sensed signal with a previous pattern or condition and will return something.

The modern image algorithms for feature extraction usually are based on deeplearning, they use something called convolutions to extract important landmarks of the images sequentially and finally compress the most important landmarks into a feature vector, but overall they could be oversimplified by something like:

These modern algorithms could be trained in two common ways:

Supervised.
Semi-supervised/Self-supervised.

Supervised

The supervised method to train feature-extractors consist of training a Convolutional model to classify an image into one of several labels.

One common set of labels are the ones of the ImageNet Dataset, which contains 1000 object classes. After training the algorithm with the imageNet data, we get the extractor part from the full model.

Then, the Feature Extractor Part could be used to get the Embeddings in the latent space.

This is the method used for the MobileNets, EfficientNets, and ALexNet Models.

Semi-supervised/Self-supervised

These methods consist on using an untrained model with an error function (measurement of correctness) based on Contrastive Loss.

The Contrastive Loss is used to measure how similar 2 vectors are in latent space(vector space), it is useful for checking the similarity between any kind of vector, even if they were extracted using different approaches.

Here we'll explain how to use this method using only images.

Basically the approach using only images is called SimCLR and consist on doing some kind of perturbation on a given Image, then, compute its embedding, and finally, check with the contrastive loss how similar is the embedding of the perturbed image to the embedding of the original unperturbed image.

The magnitude of the difference will be used to update the Feature-extractor model. Over time the model will be trained, using just multiple images and their perturbed twins, it is very useful when we don't have lots of labeled data.

Other contrastive Learning techniques could be used with embeddings from images, text, audio, etc. It is the key component behind multimodal models, and probably we'll review it in a future article.

Image-based Latent Space

The latent space is the space where images are represented by their vectors, after extracting the features of a given set of images we'll get a latent space.

Remember the previus article how there was a space of fruits and a royal family?

That space could be obtained using a lot of images of those concepts and extracting their Feature Vectors.

If we have a well trained algorithm with also some animals, and a deep understanding of them, we could use that Vision Algorithm to get the vector in the latent space of a little Monkey, and we'll obtain something like:

That way the Monkey concept obtained from passing a monkey image into a Vision Model would be somewhat close to a banana, and also close to the King and Queen concepts, since we are all mammals.

Isn't it awesome?

Businesses use this algorithms all the time, for extracting products embeddings, like clocks, toys, shoes, etc. Used in conjunction with retrieval systems one could find things that are similar in the feature space using just images!

Closing

We've seen that we can represent concepts in a N-dimensional space using only images, and the algorithms mimics in some way what the brain does.

I hope you've learned something new from this article, and I'll be glad if you send me your questions, correct me, or simply comment what do you think of it! 💯

Pd
The Next post could be an overview about multimodal Feature-Extractors, or the main concepts behind vector Retrieval Systems. I haven't decided yet.😅

And since I'm kind of slow to write these kind of articles, I could be posting some non-technical ones in the meantime.

So, take care, and keep learning!

Vector Search pt. 1 - Features 🪵

Mizuno Sutoiko — Mon, 18 Dec 2023 02:46:23 +0000

I'd never asked myself how Google, Youtube, Pinterest, or Netflix perform their searches. I was just using those services to lookup for information, shows, or images, but without even consider the underlying technology behind them, and I really didn't care.

That was until I encountered the concept of Vector Search, a concept so deeply grained in ourselves that when you get to know it, you start looking at things in very different ways.

This concept could be used to explain on a high level how retrieval systems work, how Facebook matches friends together, and even how we understand the world around ourselves.

This article is part of a series that aims to bring light to such an interesting concept that we all know and use, but very few of us really understand.

And also, how companies or individuals could use it to offer a higher value in their services.

Let's get started!

What is a Feature?

Straight to the point, a feature is a characteristic that we use to describe something. The typical examples would be, that the apples (🍎) are red, a King (🤴) is a person, etc, but if we really want to go into a deeper level, we would need longer descriptions:

An Apple (🍎) is a fruit that could have three different colors, red, green, and yellow, is a bit sweet, and it is a great source of fiber and vitamins.
A King (🤴) is a person in position of power, who is usually the husband of a Queen. They live in castles and wear a crown.

If we want to add those descriptions to a table, for the first descriptions, we could have two columns, one for the name, and one for the description. To find something, we just do a column filter and search for the words person or red.

The problem with the simple descriptions is that they would only work in a world with few objects, and in real life we should consider descriptions like the second ones to really differentiate things. There are lots of red stuff, and there are hundreds of types of persons.

But, we can't put those long texts in a table and expect to filter them like that, we need to organize the information in the key words.

Apple: ["fruit","red","green","yellow", "sweet", "fiber", "vitamins"]
King: ["person", "power", "husband", "castle","crown"]

If we add more objects like bananas and Queen, we could do something similar:

Banana: ["fruit","yellow", "sweet", "fiber", "vitamins"]
Queen: ["person", "power", "wife", "castle","crown"]

As humans, we understand the concepts behind those words without even thinking about it, because we have encountered them in real life so many times that describing them becomes easy.

We know that Bananas, apples, watermelons, and strawberries are somewhat more related among them than with other concepts like King, which would be more related to Queen a lot more than it is to apples.

That knowledge is encoded in our brains. The name for that understanding is known as Semantics, the relation between a concept and its meaning.

Going back to the imaginary table, if you try to figure out how to save and filter features to finally obtain one single thing, you could get to a very important question:

If we want to add a lot of objects, people, landscapes, animals, and fruits, it wouldn't be possible to directly add that many descriptions in columns, so how could we do it?🤔

That's a real problem in Computer Science, and probably I won't answer it in the best possible way, but one solution could be: Simplifying.

Simplifying our understanding of the world using Features

If we compare the two descriptions given at the beginning of this article we would note that the first was oversimplified, but the second one was not.

In real life scenarios, we should come up with multiple options to summarize characteristics, for example:

name, color, gender.
cell_type, is_human, lives_in_castle.

Looking for some mid-point, we could use both for our data, organize the information in a table, and get something like:

word	color	gender	cell_type	is_human	lives_in_castle
Apple	red		plant	False	False
Banana	yellow		plant	False	False
King		male	animal	True	True
Queen		female	animal	True	True

This way if we want to perform a search, create groups, or keep adding more diverse things, the summary of features will scale up, but... How much?

Summarizing the features even more

First of all, if we want to really scale things up, we would need a little help describing things. Choosing a set of characteristics that could be enough to summarize any object would be a very demanding task, and depending on the items it probably will change over time.

One interesting solution to this problem is to select pivot items, and score the similarity of any new item to those pivot items.

Note: A pivot here is like a reference point (⛳️), it allows us to guide ourselves in a space that is not well defined.

Let's choose the apple and the King as pivot items, we could add more objects and then create a similarity table:

word	Apple	King
King	0.0	1.0
Queen	0.0	0.8
Apple	1.0	0.0
Banana	0.8	0.0
Dog	0.2	0.4
Woman	0.1	0.6
Watermelon	0.8	0.0
Strawberry	0.7	0.0

Note that the similarity here is subjective

We summarized 5 feature columns in just 2, and we achieved something that will benefit us later, assessing numerically the similarity to each of the pivots.

This way we could sort the items accordingly to the similarity to each of the pivots, for example, let's sort things up depending on the similarity to the concept of King:

word	Apple	King
King	0.0	1.0
Queen	0.0	0.8
Woman	0.1	0.6
Dog	0.2	0.4
Apple	1.0	0.0
Banana	0.6	0.0
Watermelon	0.8	0.0
Strawberry	0.7	0.0

You could start to see how easy it is to keep adding items, and sorting them depending on their subjective similarity to the pivots. Those pivots could be interpreted as dimensions in a 2 dimensional plane, that means that each word could have a magnitude (lenght) and a direction in that plane! Something with those characteristics is known as a Vector, for now we'll keep plotting them as points.

Now, we can use sorting algorithms, instead of just filtering. We are able to find things more easily in the data, and define a similarity threshold to exclude the things that aren't of interest to us.

But, If we want to add thousands of items with their respective vectors to our table, do we have to think and input these similarities one by one? 😓

This question would be answered in the next part!

We'll see how can we create these tables for any object, and how a computer could enhance our experience while doing it!

See you soon! 😎

Improve your Python Skills with Classes, decorators, and implicit parameters

Mizuno Sutoiko — Fri, 01 Dec 2023 03:45:11 +0000

Python is a very common programming language. It is easy to learn the basics and start using it right away, this is specially useful for data scientists, and people from other backgrounds that don't have a lot of coding experience.

This guide aims to introduce 3 concepts that if applied correctly, you could simplify your code, add functionalities to your current methods, and pass arguments without specifying them. Also, your code will look cooler 😎.

The concepts are:

Classes.
Decorators.
*Args and **kwargs.

Classes

Python is an Object Oriented Programming Language (OOP Language), this means that we can use classes to organize our code and group related methods together.

A Python Class could be something like:

class Pokemon:
   """Class containing the available Pokemon methods"""
   def evolve(...):
   ...

The interesting part about classes is that they introduce one of the most useful things of OOP, heritage.

For example, if we have multiple classes that are somewhat related, let's say, Bulbasaur, Squirtle, and Charmander, they all should have an evolve method:

class Bulbasaur:
    def evolve(...):
    ...

class Squirtle:
    def evolve(...):
    ...

class Charmander:
    def evolve(...):
    ...

But using the example above, we could simply define a Pokemon parent class that contains the method, and all three pokemons will have it through heritage.

class Pokemon:
   """Class containing the available Pokemon methods"""
   def evolve(...):
   ...

class Bulbasaur(Pokemon):
    ...

class Squirtle(Pokemon):
    ...

class Charmander(Pokemon):
    ...

eric = Bulbasaur()
eric.evolve()
# >>Evolving to Ivisaur

And with that all three pokemons could make use of the method defined in the parent class.

This helps us make our code scalable, maintainable and also easier to read.

Decorators

Decorators are a way of altering a method's functionality by using another method that receives the target method as an argument.

For example, let's say that we are going to make the evolve method of the pokemons to print the elapsed time that took the pokemon to evolve.

There are several ways of doing this, but we are using a decorator for it.

def measure_time(func):
    start = time.time()
    func()
    end = time.time()
    print(f"The elapsed time was {end - start} seconds!")

To use it we should use the decorator with an "@" above the function definition, something like this:

@measure_time
def evolve(...)
    ...

print(evolve)
# >>The elapsed time was 7.152557373046875e-07 seconds!

We could also have decorators with parameters. One useful resource for understanding this is this stackoverflow's answer.

Let's say that we have two Bulbasaurs and one of them tackles the other.

Example:

def print_used_attack(f):
    def attack(*xs, **kws):
        return f(*xs, **kws)
    print(f"Used {f.__name__}")
    return attack

class Bulbasaur():
    def __init__(self):
        self.health = 100

    @staticmethod
    @print_used_attack
    def tackle(target_pokemon):
        return target_pokemon.health - 15

eric = Bulbasaur()
tommy = Bulbasaur()

tommy.health = eric.tackle(tommy)
# >>Used Tackle
print(tommy.health)
# >>85

Here, anytime the tackle method is used, a string like "Used attack_name" will be printed in the console, this is useful if we want to add logs to a method that receives multiple arguments.

And, the magic of this decorator is that if we define more attacks like vine_whip or leech_seed, and we use the decorator with them, a log will be printed in the console with the used attack!

*Args and **Kwargs

These are abreviations for Arguments and Key-arguments.

Note that the important part is the use of "*" and "**", the name could be different form args and kwargs, those names are just conventions.

*Args

The *args abreviation allow us to define a method without argument constraints.

Example:

damage_history = [3,3,5,6,6,7]

def sum_attack_damage(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_attack_damage(*damage_history))
# >>30

The use of the *args as a form of receiving the parameters give us the possibility of passing multiple arguments, and being able to sum them without limiting the number!

**Kwargs

The **kwargs abreviation allows us to define a method that could receive a dict with the parameters' names as keys.

Example:

def evolve_pokemon(pokemon, base_evolution, first_evolution, second_evolution):
    if pokemon == base_evolution:
         return first_evolution
    elif pokemon == first_evolution:
        return second_evolution
    else: return pokemon

pokemon_data={
    "base_evolution": "Pichu",
    "first_evolution":"Pikachu",
    "second_evolution":"Raichu"
}

print(evolve_pokemon("Pichu",**pokemon_data)) 
# >>Pikachu
print(evolve_pokemon("Raichu",**pokemon_data)) 
# >>Raichu

As you see in the example, it is not necessary to pass parameter by parameter to the function, we just passed a dict with the ** at the beginning to signal that it should be treated as a kwarg.

Conclusion

Learning python could be a long process, but I hope that with this article, and some future ones, I could explain in a simple manner difficult concepts that are really useful for our journey.

I hope you find this interesting, and if you want to deepen on something, have suggestions, or want me to explain some other concept, you could leave a comment below.

Happy Programming!