A Look Into The Future Of Wireless Brain-Computer Interfaces.

 

Brain-computer interfaces (BCI) or what some call the mind-machine interface is a system of connecting a human brain through wires or wirelessly to a machine in order to generate signals from the brain, transmit them to a computer and through a bidirectional information flow mechanism allow the computer to control motor functions of the human brain.

The idea of a mind-machine interface was popular in the 1970s but it was not until the 1990s that prosthetic devices that were attached to the brain appeared to be viable. One of the concepts behind these mind-machine devices is to capture the electrical activity of the brain through electroencelography (EEG), transmit them to a machine and then the machine generates signals that are able to control the functioning of the brain. Professor Jacques Vidal of the University of California, Los Angeles (UCLA) is credited with inventing the first BCI machine. This concept has been applied in neuroprosthetics which is the use of artificial devices to replace the function of impaired nervous functions and brain related problems.

Thanks to this inventive and innovative approach, many persons who have lost their vision, motor movements, and other body functions such as in paralysis, can be able to live normal lives using these machines. A breakthrough in BCI devices and neuroprosthetics was accomplished in 2009 when Alex Blainey, an independent researcher living in the UK, was able to control a 5 axis robot arm using the Emotiv EPOC. These devices could help even someone who has lost control of their spinal cord through a disease or injury to regain full movement .

One drawback though was that not only do they require wires but they can generate energy in the brain of recipients. A wired BCI device can limit the movement of the person on whose brain it is implanted. They would not be free to move at ease. While a BCI device generating enormous energy could do harm to the person on whom it is implanted.

Now, these challenges could be a thing of the past as research has suggested that neural implants in the brain could be done wirelessly while generating just one-tenth of the power of existing devices.

A team of electrical engineers and neuroscientists from Stanford University successfully created a breakthrough device that could give recipients a wider range of movement while not exposing them to harm through the heat generated by the implanted device. To test their data, they tried out their experiment on three nonhuman primates and one human participant in a clinical trial. Then while the subjects performed several movements by communicating with the computer using their brains, the researchers took extensive measurements. The results of the research validated the hypothesis from the researchers that a wireless device for neuroprosthesis was possible and commercially viable while using less power.

Only time would tell when the actual device would be built that would actually achieve the goal of the research: a mind-machine device that was safe yet wireless. The future of wireless brain-computer interfaces is just within reach.

How To Do Python Keyword Arguments Like An Expert

It is a little daunting for people who are new to python or transitioning to python from other languages to understand how keyword arguments work when compared to positional arguments. I will succinctly explain each of them here and show you how to use keyword arguments like a pro in no time.

Arguments in python are parameters that are passed to functions. When a function is called, a scope is created for the function with the arguments bound to the parameters within that scope. The argument could be a variable, value or object that is passed to the function (or method) as input.

There are two types of arguments that could be passed to python functions. They are positional arguments and keyword arguments.

Positional arguments are arguments that need to be included by the caller in their proper position or order in the function definition. Let’s take the complex() built-in function as an example. The syntax is complex([real[, imag]]) where the first argument is the real number and the second is the imaginary number. In complex numbers, the position is very important. A complex number with real 2 and imaginary number 3 is written as 2 + 3j. If the order is mistaken, then you have a different complex number. You need to note this when using the complex function. For example take this code sample below:

 

You can see from running the code that I interchanged the 2 and 3 just to show you how positional arguments work. When you change the position of the arguments, you get a different result. You must give the function the same number of arguments as is defined in the positional arguments, else it will return an error.

But there are times when you want to pass a sequence of arguments, such as an iterable to the function, then you can use the * operator to do this. Notice that I used this * operator in line 6 in the code below. This unpacks the iterable and passes each of the items in the iterable to the function in order.

 

What are keyword arguments?

Keyword arguments, as the name denotes, are arguments that are passed with a key=value syntax. That is a key first, an = sign, and then a value. Unlike positional arguments, the position of parameters or the order does not matter. You can state the arguments in any order you like. What matters are the names of the keys. In fact, when you pass a keyword argument, python creates a dictionary of key=value pairs for the arguments and inserts it into the function appropriately.

Let’s take an example using our complex function again.

 

You can see from line 1 and 3 that I interchanged the positions of the arguments while specifying their key=value pairs and it gave me the same object.

Keyword arguments can seem odd as we go on to take more complex examples, but I want you to know that as you practice with it, it would become more natural and you would love using them. They have advantages.

In python documentation, the phrase "keyword argument" is often shortened to kwargs. So when you see such shorthand know that it signifies keyword arguments.

What are the advantages of using keyword arguments.

1. With keyword arguments, we can leave off some of the arguments and the default is used for those that are left off.

Notice that in line 4 first_name was not given to the function and I asked it to use the default. In line 5, I did not pass any argument at all, instead it just used the default.

2. If we want to achieve readability in passing arguments, we can rearrange the arguments to make them readable.

The ability to rearrange the arguments at your willing makes you creative and provides code you can understand in the future.

3. Objects that are being passed to the function are clear to use when we are passing them.

Since we are using their names to pass them, we understand what we are doing in case we need to debug or read the code in the future. Consider these two lines for passing arguments to the complex function, which do you think is more readable?

 

Line 1 and line 3 creates the same object, but you must agree with me that line 3 is more readable because looking at the keys you can easily know what object you are passing to the function.

Now that we have a basic idea of keyword arguments and how they are used in python, let us illustrate some more features of keyword arguments with more examples.

Keyword arguments and examples

One example of a built-in function that requires a keyword argument in python is the sorted function. After the first iterable, every other argument that is passed to the function must be a keyword argument. In the code below, I tried reversing the sort order without passing a keyword argument of reverse=True and it returned a TypeError.

 

There is a handy technique that comes in handy when you want to require that all your keyword arguments be named while having the ability to pass on arbitrary positional arguments. That is mixing positional and keyword arguments at the same time. When the positional arguments are more than one, you can use the *parameter statement (where parameter is a variable, value or object) to specify this. Remember, as I said before, when stating a keyword argument with a positional argument, the moment you insert a keyword argument in the parameter list, any other argument that comes next must be a keyword argument.

Let’s take this summing function as an illustrative example. It sums all the numbers passed starting from 1 as default. Notice that I did not pass the parameter, initial, as argument, because I wanted to use it as default. You can experiment with it. What if you want to make the initial starting point 2 or 3? What sum would it return?

 

Also, to take our knowledge one step further, what if you don’t want to specify any positional arguments but you want an arbitrary number of keyword arguments. You use the statement **kwargs. You must have seen this often in the python documentation. What python does when it sees this in the function definition is to create a dictionary with the key=value of the passed in parameters. Let’s illustrate this with an example.

 

When using the **kwargs statement, order matters to the python interpreter. It will evaluate all the keys according to the order that they were passed.

I encourage you to use keyword arguments often. They give beauty to your programs. If you are not familiar with them, when writing any function ask yourself: can I use keyword arguments for this and make it more readable? It would solve you a whole lot of headache in the future.

The Next Big Thing About the Cerebellum Might Open Frontiers In Understanding The Brain

The cerebellum, which in Latin means “the little brain,” is at the hindbrain in all vertebrates. North of the cerebellum is the cerebral cortex which forms its outer layer. Formerly, due to its folding nature, the cerebellum was thought to be smaller than the cerebral cortex and so not much involved in as much activities in human behavior and cognition as the cortex. But recent research has disproved that point.

The cerebellum as earlier said was thought to be smaller because it is arranged in hundreds of folds which make it look small in surface area but researchers using ultra-high-field MRI imaging together with specialized software have found that the surface of the cerebellum is much larger than was believed. It was even found to be even bigger than the cerebral cortex. It is now said to be approximately more than 80 percent of the cerebral cortex.  

This research would now open the way for more research into the benefits of the cerebellum for human behavior and cognition. This is because since the cerebellum is bigger than the cortex, it shows that human evolution is more advanced than other vertebrates, even those closer to man like the macaque monkeys. Therefore, it will help us to understand how over the years man has adapted better than other vertebrates to the environment and has used the advantage afforded it by a bigger cerebellum to develop advanced levels of cognitive abilities.

The researchers also found that while the cerebral cortex was well arranged and the body parts they were controlling well defined, that is not the case for the cerebellum. The cerebellum receives information from disparate parts of the body in a random manner. That means, areas for coordinating the shoulder could lie side by side with areas coordinating the foot. This gives humans the advantage over other animals of coordinating different body parts all at the same time from one central location, enhancing efficiency.

Also, the researchers found that the cerebellum must have a higher role in controlling emotional responses more than was earlier thought. It is established that the cerebellum is involved in movement-related functions, but this study also delved into the study of damaged cerebellums and found that people with such challenges had problems understanding their emotions. But further research has to be done in this area.

In the coming years, with the results from the MRI study, researchers will be able to better understand how the brain works and not confine their knowledge to thinking the control of body functions is limited to specific areas of the brain. Mapping the cerebellum will be an interesting new frontier for scientific advancement and further understanding of the human body.

Expectations And Realities Of Python Lists And Dictionaries

Have you ever got stumped when you tried assessing an item in a list or dictionary because you received a result which you never expected? Some would say they found a bug. Truly, that bug rests in the fact that you did not understand the subtleties between types when using a list or dictionary.

Take this little program that shows the subtleties in accessing items in a dictionary.

The dictionary has three items, with the keys being ints and the values as strings. That is the first difference you should notice. This is just illustrative because keys of dictionaries can also be any immutable type. On line 3, I asked the interpreter to tell me if 10, int type, was a key, and if ‘10’, string type, was a key. It says True for the former and False for the latter. This is a problem I encounter while teaching on a daily basis. Many persons tend to confuse the int for the string and vice versa. They are different values.

Then comes accessing the items in the dictionary. On line four, I inserted 10 as the key to the dictionary. Note this: as key and not the index. Python reported the string, ten, as I expected. But notice what happens on the line 5 when I used the string ‘10’ as the index. Python gave a KeyError.

So, this shows that types really matters when you are accessing dictionaries. The same goes for lists.

How to find items in a list and dictionary.

Imagine we have a list of names.

When you run it, you should notice that the int 1 is not in the list. I could have used some other value, maybe ‘one’ or maybe ‘Rose’ but the "in" operator shows us whatever is in the list. One problem I have encountered with most of my students is that they don’t understand the subtleties of the in operator. What I always tell them is to consider it as going through each item in the list and looking for a match. If it returns a match, it returns True, and if not it returns False.

Now, what if we mistake an int for a string or vice versa in the list. Let’s take another list. This time of years.

If you run it, what it prints out is:

2019 in list.
2019 is not in list.

What is going on? It’s just simple. The items in the list are strings but on line 10 we gave it an int. So, when programming you have to be very careful not to be carried away and confuse an int for a string and vice versa.

What about indexing and keys.

What we expect is that when we give the interpreter something like variable_name[index] when it is an iterable, we should expect to get an item in return. But what item we get depends on the data structure we are using. If variable_name is a list, we will get an item in the list with that index. But if variable_name is a dictionary, what we get is a value of the key, index.

That gets many people confused sometimes. Well, it is all about knowing that lists and dictionaries are arranged differently. A list contains references to items of value and each item is indexed from zero. For example, let’s take our list of names again.

names = ['david', 'michael', 'daniel']

The list has three items which are referenced through an index. 'david' is at index 0, 'michael' is at index 1, and 'daniel' is at index 2. So, we can access the items through the indices. For example this command, names[0] will return david, while names[2] will return daniel.

But this is different with dictionaries. Let’s take a dictionary of ints as keys and strings as values for example.

num_dict = {10 : 'ten', 20 : 'twenty', 30 : 'thirty'}

If we run the statement num_dict[0] we will get a KeyError. You know why? Because dictionaries accesses its values based on the keys and 0 is not a key in the num_dict dictionary. So, don’t confuse this with that of lists. To access the second item in the dictionary which is ‘twenty’, we need to get it through its key, and the key is an int, 20. So we run the statement thus: num_dict[20] which returns ‘twenty’.

Note that keys of dictionaries can only be immutable types, including sets, while values for dictionaries can be of any type.

I hope you enjoyed this article. If you like receiving more solved problems like this from this blog, just subscribe and it will be sent to your inbox the moment I publish a new article.