Robley Gori

AWS S3 is a great, low-cost service for file storage. In this article, we'll be using Python and Django to upload files to AWS S3.

Uploading Files to AWS S3 with Python and Django

David Landup

Janith Kasun

REST APIs are the most common form of APIs nowadays. In this article, we'll be building a simple REST API in JavaScript using Node.js and Express.

Building a REST API with Node and Express

Ali Abdelaal

In a data-driven world - optimizing its size is paramount. Autoencoders automatically encode and decode information for ease of transport. In this article, we'll be using Python and Keras to make an autoencoder using deep learning.

Autoencoders for Image Reconstruction in Python and Keras

In computer science and electronics, there are quite a few ways to represent data, often called encoding schemes. Each has its own purpose, advantages, and disadvantages. In this short article we'll take a look at one-hot encoding and see what it is, how it compares to other similar schemes, and its applications.
<h2 id="whatisonehotencoding">What is One-Hot Encoding?</h2>
One-hot encoding is a sparse way of representing data in a binary string in which only a single bit can be 1, while all others are 0. This contrasts from other encoding schemes, like binary and gray code, which allow multiple multiple bits can be 1 or 0, thus allowing for a more dense representation of data.
A few examples of a one-hot encoding might look like this:
<pre><code class="hljs">000010
001000
100000
000100
</code></pre>
This concept can better be understood by comparing the representation of the numbers 0-4 in binary, gray code, and one-hot:
<table class="table table-striped">
 <thead>
 <tr>
 <th>Decimal</th>
 <th>Binary</th>
 <th>Gray code</th>
 <th>One-hot</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>0</td>
 <td>000</td>
 <td>000</td>
 <td>0000000</td>
 </tr>
 <tr>
 <td>1</td>
 <td>001</td>
 <td>001</td>
 <td>0000001</td>
 </tr>
 <tr>
 <td>2</td>
 <td>010</td>
 <td>011</td>
 <td>0000010</td>
 </tr>
 <tr>
 <td>3</td>
 <td>011</td>
 <td>010</td>
 <td>0000100</td>
 </tr>
 <tr>
 <td>4</td>
 <td>100</td>
 <td>110</td>
 <td>0001000</td>
 </tr>
 <tr>
 <td>5</td>
 <td>101</td>
 <td>111</td>
 <td>0010000</td>
 </tr>
 <tr>
 <td>6</td>
 <td>110</td>
 <td>101</td>
 <td>0100000</td>
 </tr>
 <tr>
 <td>7</td>
 <td>111</td>
 <td>100</td>
 <td>1000000</td>
 </tr>
 </tbody>
</table>
Notice how more digits are needed than in the other two representations. Each digit location can only refer to a single number and can't be used to represent any other numbers. Because of this, a one-hot encoding of n digits can only represent n values. Whereas the binary encoding, for example, with n digits can represent 2n values.
<h2 id="applicationsofonehotencoding">Applications of One-Hot Encoding</h2>
So if one-hot encoding has such a strict limit on the amount of data that can be conveyed in a binary string, what practical uses does it actually have? Quite a few important ones, actually. Its importance is explained well by <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/One-hot">Wikipedia</a>:
<blockquote>
One-hot encoding is often used for indicating the state of a state machine. When using binary or Gray code, a decoder is needed to determine the state. A one-hot state machine, however, does not need a decoder as the state machine is in the nth state if and only if the nth bit is high.
</blockquote>
<h3 id="machinelearning">Machine Learning</h3>
<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Artificial_neural_network">Neural networks</a> and <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Deep_learning">deep learning</a> have become the fastest growing discipline in the field of computer science, and for good reason. These machine learning methods have provided a solution to historically difficult, or even impossible, problems in computer science. And, maybe surprisingly, one-hot encoding has an important part in it.
Neural networks, and thus deep learning, are inspired by the neural networks that compose our brains. They consist of simple neurons and connections between the neurons. The output from each neuron usually represents a number, which is used throughout the network for computation. While this number can theoretically have any value, it is usually cast to a 1 or 0 in order to represent categorical data.
For example, let's say we have a neural network that can tell us if an input image is of a cat or a dog. Since the neural network only uses numbers, it can't output the words &quot;cat&quot; or &quot;dog&quot;. Instead, it uses one-hot encoding to represent is prediction:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/one-hot-encoding-1.png">
In this example, the output of the top neuron in the image above might represent the prediction of &quot;cat&quot; and the bottom neuron's output might represent the prediction of &quot;dog&quot;. Whichever output is a 1 would indicate the prediction.
<h3 id="electronics">Electronics</h3>
In electronics, many of the times one-hot encoding is used for very similar scenarios as in machine learning. An analog or digital output line can represent a value using voltage.
For example, logic gate circuits are much like neural networks in that they are composed of a large network of interconnected &quot;nodes&quot;, with digital inputs creating some corresponding digital output. While binary representation is common in electronics, one-hot can be a better alternative to represent a an output state without the need for any decoding.
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/one-hot-encoding-2.png">

Scott Robinson

One-hot encoding is a sparse way of representing data in a binary string in which only a single bit can be 1, while all others are 0.

One-Hot Encoding

Usman Malik

The seq2seq architecture is a type of many-to-many sequence modeling. In this article, we'll create a machine translation model in Python with Keras.

Python for NLP: Neural Machine Translation with Seq2Seq in Keras

Muhammad Junaid Khalid

The PyAutoGUI library provides cross-platform support for managing mouse and keyboard operations through code to enable automation of tasks.

Getting Started with Python PyAutoGUI

<h2 id="introduction">Introduction</h2>
JavaScript is single-threaded, which means that everything, including events, runs on the same thread. If the thread is not free, code execution is delayed until it is. This can be a bottleneck for our application since it can really cause serious performance problems.
There are different ways by which we can overcome this limitation. In this article, we'll explore the modern way to handle asynchronous tasks in JavaScript - <code>Promise</code>s.
<h2 id="callbacksandcallbackhell">Callbacks and Callback Hell</h2>
If you are a JavaScript developer, you've likely heard of, if not used, callbacks:
<pre><code class="hljs">function hello() {
 console.log(&#x27;Hello World!&#x27;);
}

setTimeout(hello, 5000);
</code></pre>
This code executes a function, <code>setTimeout()</code>, that waits for the defined time (in milliseconds), passed to it as the second argument, <code>5000</code>. After the time passes, only then does it execute the function <code>hello</code>, passed to it as the first parameter.
The function is an example of a higher-order function and the function passed to it is called a callback - a function that is to be executed after another function has finished executing.
Let's say that we sent a request to an API to return the most-liked photos from our account. We may likely have to wait for the response as the API/service may be doing some calculations before returning the response.
This can potentially take a long time, and we do not want to freeze the thread while we wait for the response. Instead, we'll create a callback that will be notified when the response comes in.
Until that time, the rest of the code is being executed, like presenting posts and notifications.
If you've ever worked with callbacks, there's a chance you've experienced <a target="_blank" href="/avoiding-callback-hell-in-node-js/">callback hell</a>:
<pre><code class="hljs">doSomething(function(x) {
 console.log(x);
 doSomethingMore(x, function(y) {
 console.log(y);
 doRestOfTheThings(y, function(z) {
 console.log(z);
 });
 });
});
</code></pre>
Imagine a case where we request the server to get multiple resources - a person, their friends and their friend's posts, the comments for each friends' posts, the replies, etc.
Managing these nested dependencies can quickly get out of hand.
We can avoid callback hells and handle asynchronous calls by using <code>Promise</code>s.
<h2 id="creatingapromise">Creating a Promise</h2>
<code>Promise</code>s, as the name implies, is the function &quot;giving its word&quot; that a value will be returned at a later time. It's a proxy for a value that might not be returned, if the function we expect a response from doesn't deliver.
Instead of returning concrete values, these asynchronous functions return a <code>Promise</code> object, which will at some point either be fulfilled or not.
Most often, when coding, we'll be consuming <code>Promise</code>s rather than creating them. It is the libraries/frameworks that create <code>Promise</code>s for the clients to consume.
Still, it is good to understand what goes behind creating a <code>Promise</code>:
<pre><code class="hljs">let promise = new Promise(function(resolve, reject) {
 // Some imaginary 2000 ms timeout simulating a db call
 setTimeout(()=&gt; {
 if (/* if promise can be fulfilled */) {
 resolve({msg: &#x27;It works&#x27;, data: &#x27;some data&#x27;});
 } else {
 // If promise can not be fulfilled due to some errors like network failure
 reject(new Error({msg: &#x27;It does not work&#x27;}));
 }
 }, 2000);
});
</code></pre>
The promise constructor receives an argument - a callback. The callback can be a regular function or an arrow function. The callback takes two parameters - <code>resolve</code> and <code>reject</code>. Both are function references. The callback is also called the executor.
The executor runs immediately when a promise is created. The promise is resolved by calling <code>resolve()</code> if the promise is fulfilled, and rejected by calling <code>reject()</code> if it can't be fulfilled.
Both <code>resolve()</code> and <code>reject()</code> take one argument - <code>boolean</code>, <code>string</code>, <code>number</code>, <code>array</code>, or an <code>object</code>.
<h2 id="consumingapromise">Consuming a Promise</h2>
Through an API, say we requested some data from the server and it's uncertain when it'll be returned - if it'll be returned at all. This is a perfect example of when we'd use a <code>Promise</code> to help us out.
Assuming that the server's method that handles our call returns a <code>Promise</code>, we can consume it:
<pre><code class="hljs">promise.then((result) =&gt; {
 console.log(&quot;Success&quot;, result);
}).catch((error) =&gt; {
 console.log(&quot;Error&quot;, error);
})
</code></pre>
As we can see we have chained two methods - <code>then()</code> and <code>catch()</code>. These are a few of the various methods provided by the <code>Promise</code> object.
<code>then()</code> is executed when things go well, i.e the promise is fulfilled by the <code>resolve()</code> method. And if the promise was rejected, the <code>catch()</code> method will be called with the error sent to <code>reject</code>.
<h2 id="chainingpromises">Chaining Promises</h2>
If we have a sequence of asynchronous tasks one after another that need to be performed - the more nesting there is, the more confusing the code becomes.
This leads us to callback hell, which can easily be avoided by chaining several <code>then()</code> methods on a single <code>Promise</code>d result:
<pre><code class="hljs">promise.then(function(result) {
 // Register user
 return {account: &#x27;blahblahblah&#x27;};
}).then(function(result) {
 // Auto login
 return {session: &#x27;sjhgssgsg16775vhg765&#x27;};
}).then(function(result) {
 // Present WhatsNew and some options
 return {whatsnew: {}, options: {}};
}).then(function(result) {
 // Remember the user Choices
 return {msg: &#x27;All done&#x27;};
});
</code></pre>
As we can see the result is passed through the chain of <code>then()</code> handlers:
<ul>
<li>The initial <code>promise</code> object resolves</li>
<li>Then the <code>then()</code> handler is called to register user</li>
<li>The value that it returns is passed to the next <code>then()</code> handler to auto login the user</li>
<li>...and so on</li>
</ul>
Also, the <code>then(handler)</code> may create and return a promise.
Note: Although technically we can do something like the proceeding example, it can take away from the point of chaining. Although this technique can be good for when you need to optionally call asynchronous methods:
<pre><code class="hljs">let promise = new Promise(function(resolve, reject) {
 setTimeout(() =&gt; resolve({msg: &#x27;To do some more job&#x27;}), 1000);
});

promise.then(function(result) {
 return {data: &#x27;some data&#x27;};
});

promise.then(function(result) {
 return {data: &#x27;some other data&#x27;};
});

promise.then(function(result) {
 return {data: &#x27;some more data&#x27;};
});
</code></pre>
What we are doing here is just adding several handlers to one promise, all of which process the <code>result</code> independently. They are not passing the result to each other in the sequence.
This way, all handlers get the same result – the result of that promise - <code>{msg: 'To do some more job'}</code>.
<h2 id="conclusion">Conclusion</h2>
<code>Promise</code>s, as the name implies, is the function &quot;giving its word&quot; that a value will be returned at a later point in time. It's a proxy for a value that might not be returned, if the function we expect a response from doesn't deliver.
Instead of returning concrete values, these asynchronous functions return a <code>Promise</code> object, which will at some point either be fulfilled or not.
If you have worked with callbacks, you must appreciate the clean and clear semantics of <code>Promise</code>s.
As a Node/JavaScript developer, we'll be dealing with promises more often. After all, it is an asynchronous world, full of surprises.

Shadab Ansari

A Promise is an asynchronous function "giving its word" that a value will be returned at a later time. Introduced in ES6/ES2015, Promises provide a modern alternative to callbacks

Promises in Node.js

<h2 id="introduction">Introduction</h2>
Nowadays, most programs are written in a high-level language such as C, Java, or Python. These languages are designed more for people, rather than machines, by hiding some hardware details of a specific computer from the programmer.
Simply put, high-level languages simplify the job of telling a computer what to do. However, since computers only understand instructions in machine code (in the form of 1's and 0's), we can not properly communicate with them without some sort of a translator.
This is why language processors exist.
The language processor is a special translator system used to turn a program written in a high-level language, which we call &quot;source code&quot;, into machine code, which we call &quot;object program&quot; or &quot;object code&quot;.
In order to design a language processor, a very precise description of lexicon and syntax, as well as semantics of a high-level language, is needed.
There are three types of language processors:
<ul>
<li>Assembler</li>
<li>Interpreter</li>
<li>Compiler</li>
</ul>
In the next few sections we'll go over each of these types of processors and discuss their purpose, differences, etc.
<h2 id="assemblylanguagesandtheassembler">Assembly Languages and the Assembler</h2>
Most assembly languages are very similar to machine code (which is why they are specific to a computer architecture or operating system), but instead of using binary numbers in order to describe an instruction, it uses mnemonic symbols.
Each mnemonic symbol represents an operation code or instruction, and we typically need several of them in conjunction to do anything useful. These instructions can be used to move values between registers (in Intel86-64 architecture this command would be <code>MOV</code>), to do basic arithmetic operations on values such as addition, subtraction, multiplication, and division(ADD, SUB, MUL, DIV), as well as the basic logical operations like shifting a number left or right or negation (<code>SHL</code>, <code>SHR</code>, <code>NEG</code>). It can also use unconditional and conditional jumps, which is useful in order to implement a &quot;for&quot; loop, &quot;while&quot; loop, or an &quot;if&quot; statement (<code>JMP</code>, <code>JE</code>, <code>JLE</code>...).
For example, if the processor interprets the binary command <code>10110</code> as &quot;move from one register into another register&quot;, an assembly language would replace it with a command, such as <code>MOV</code>.
Each register also has a binary identifier, such as <code>000</code>. This can also be replaced with a more &quot;human-like&quot; name, such as <code>EAX</code>, which is one of the general registers in x86.
If we, say, wanted to move a value into a register, the machine code would look something like:
<pre><code class="hljs">00001 000 00001010
</code></pre>
<ul>
<li>00001: Is the move command</li>
<li>000: Is the register's identifier</li>
<li>00001010: Is the value we want to move</li>
</ul>
In an assembly language, this can be written as something like:
<pre><code class="hljs">MOV EAX, A
</code></pre>
<ul>
<li><code>MOV</code> is the move command</li>
<li><code>EAX</code> is the register's identifier</li>
<li><code>A</code> is the hexadecimal value we want to move (10 in decimal)</li>
</ul>
If we wanted to write down a simple expression <code>EAX = 7 + 4 - 2</code> in machine code, it would look something like this:
<pre><code class="hljs">00001 000 00000111
00001 001 00000100
00010 000 001
00001 001 00000010
00011 000 001
</code></pre>
<ul>
<li>00001 is the &quot;move&quot; command</li>
<li>00010 is the &quot;addition&quot; command</li>
<li>00011 is the &quot;subtraction&quot; command</li>
<li>000, 001 are the registers' identifiers</li>
<li>00000111, 00000100, 00000010 are the integer values we are using in this expressions</li>
</ul>
In assembly, this bunch of binary numbers would be written as:
<pre><code class="hljs">MOV EAX, 7
MOV R8, 4
ADD EAX, R8
MOV R9, 2
SUB EAX, R9
</code></pre>
<ul>
<li><code>MOV</code> is the move command</li>
<li><code>ADD</code> is the addition command</li>
<li><code>SUB</code> is the subtraction command</li>
<li><code>EAX</code>, <code>R8</code>, <code>R9</code> are the registers' identifiers</li>
<li>7, 4, 2: are the integer values we are using in this expressions</li>
</ul>
Although still not as readable as a high-level language, it's still a lot more humanly readable than the binary command. The hardware components of the CPU and registers are by far more abstract.
This makes it easier for a programmer to write source code, not needing to manipulate numbers in order to program. Translation to object code in machine language is simple and straightforward, done by an assembler.
Since the source code is already pretty similar to machine code, there's no need to compile or interpret the code - it's assembled as is.
<h2 id="interpretedlanguagesandtheinterpreter">Interpreted Languages and the Interpreter</h2>
Every program has a translating phase, and an execution phase. In interpreted languages, these two phases are intertwined - instructions written in a high-level programming language are directly executed without being previously converted to object code or machine code.
Both of the phases are done by an interpreter - a language processor that translates a single statement (line of code), executes it immediately and then moves on to the next line. If faced with an error, an interpreter terminates the translating process at that line and displays an error. It cannot move on to the next line and execute it unless the previous error is removed.
Interpreters have been used since 1952, and their job was to ease programming within limitations of computers at the time (for example, there was significantly less storage space in the first generation of computers than there is now). The first high-level interpreted language was Lisp, first implemented in 1958 on an IBM704 computer.
The most common interpreted programming languages nowadays are Python, Perl, and Ruby.
<h2 id="compiledlanguagesandthecompiler">Compiled Languages and the Compiler</h2>
Unlike in interpreted programming languages, the translating phase and the execution phase in compiled programming languages are completely separated, and the translation is done by a compiler.
The compiler is a language processor that reads the complete source code written in a high-level language and translates it into an equivalent object code as a whole. Typically, this object code is stored in a file. If there are any errors in the source code, the compiler specifies them at the end of compilation, along with the lines in which the errors were found. After their removal, the source code can be recompiled.
Low-level languages are usually compiled because, being directly translated into machine code, they allow the programmer much more control over hardware components like memory or CPU.
The first high-level compiled programming language was FORTRAN, made in 1957 by a team led by John Backus at IBM.
The most common compiled languages nowadays are C++, Rust, and Haskell.
<h2 id="bytecodelanguages">Bytecode Languages</h2>
Bytecode languages, also called &quot;portable code&quot; or &quot;p-code&quot; languages are the type of programming languages that fall under categories of both interpreted and compiled languages since they make use of both compilation and interpretation when translating and executing the code.
Bytecode is, simply put, a program code that has been compiled from source code into low-level code designed for a software interpreter. After the compilation (from source code to bytecode), it can be compiled further into machine code, which is recognized by the CPU, or it can be executed by a virtual machine, which then acts as the interpreter.
The bytecode is universal and can be transferred in the compiled state to other devices (with all of the advantages of compiled code). The CPU then converts it into the specific machine code for the device. That being said, you can compile the source code once and run it everywhere - granted the device has another layer, which is used to convert the bytecode into machine code.
The most well-known virtual machine for bytecode interpretation is the Java Virtual Machine (JVM), which is so common that several languages have implementations built to run on it.
<img src="https://stackabuse.s3.amazonaws.com/media/programming-language-processors-1.png" alt="">
Credit: <a rel="nofollow" target="_blank" href="https://www.viralpatel.net/java-virtual-machine-an-inside-story/">ViralPatel</a>
When the program is first run in a bytecode language, there is a delay while the code compiles into bytecode, but the execution speed is significantly increased compared to standard interpretative languages (since the source code is optimized for the interpreter).
One of the biggest advantages of bytecode languages is its platform independence, which used to be typical only for interpreted languages, while the programs are much faster than regular interpreted languages when it comes to execution.
Another thing worthy of mention here is just-in-time (JIT) compilation. As opposed to ahead-of-time (AOT) compilation, the code is being compiled as it's running. This essentially improves the compilation speed and utilizes the performance benefits of compilation with the flexibility of interpretation.
Then again, dynamic compilation doesn't always have to be better/faster than static compilation - it mostly depends on which kind of project you're working on.
The flagship languages that are compiled into bytecode are Java and C# and with them are languages such as Clojure, Groovy, Kotlin, and Scala.
<h2 id="advantagesanddisadvantagescompiledvsinterpreted">Advantages and Disadvantages: Compiled vs Interpreted</h2>
<h3 id="performance">Performance</h3>
Since a compiler translates an entire source code of a programming language into executable machine code for CPU, it takes a large amount of time to analyze the source code, but once the analysis and compilation are finished, the overall execution is much faster.
On the other hand, the interpreter translates the source code line by line, each one being executed as it gets translated, which leads to faster analysis of the source code, but the execution is significantly slower.
<h3 id="debugging">Debugging</h3>
The debugging is much easier when it comes to interpreted programming languages because the code is being translated until the error is met, so we know exactly where it is, and it is easier to fix.
Contrarily, debugging in a compiled language is much more tedious. If a program is written in a compiled language, it has to be manually compiled, which is an additional step in order to run a program. This may not seem like an issue - and it isn't with small programs.
Please keep in mind that massive projects can take tens of minutes and some even hours to compile.
Moreover, the compiler generates the error message after it has scanned the source code as a whole, so the error could be anywhere in the program. Even if the line of an error is specified, after changing the source code and fixing it, we need to recompile it and only then can the improved version be executed. This may not seem like an issue - and it isn't with small programs.
Please keep in mind that massive projects can take tens of minutes and some even hours to compile. Fortunately, many errors can be noticed before compilation with the help of IDEs, but not all of them.
<h3 id="sourcecodevsobjectcode">Source Code vs Object Code</h3>
For interpreted programming languages, the source code is necessary for the execution. This means that the source code of the application is exposed to the user - like JavaScript is exposed in the browser.
Allowing users to fully read the source code may allow malicious users to manipulate and find loopholes in the logic. This can, to an extent, be limited using code obfuscation, but it's still a lot more easily accessible than compiled code.
On the other hand, once the program written in a compiled programming language is compiled into object code, it can be executed an infinite number of times, and the source code is not needed anymore.
This is why, when passing the program to a user, it is enough to just send them the object code, and not the source code, usually in the form of an <code>.exe</code> file on Windows.
Interpreted code is more susceptible to code injection attacks and the fact that they're not type-checked introduces us to a whole new set of programming exceptions and errors.
<h2 id="conclusion">Conclusion</h2>
There is no &quot;better&quot; way of translating source code, and both compiled and interpreted programming languages have their advantages and disadvantages, as mentioned above.
In a lot of cases, the line between &quot;compiled&quot; and &quot;interpreted&quot; isn't clearly defined when it comes to more modern programming language, really, there's nothing stopping you from writing a compiler for an interpreted language, for an example.

Mila Lukic

The language processor is turns a program written in a high-level language into machine code.

Programming Language Processors

The <a rel="nofollow" target="_blank" href="https://numpy.org/">Numpy</a> library can be used to perform a variety of mathematical/scientific operations such as matrix cross and dot products, finding sine and cosine values, <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Fourier_transform">Fourier transform</a> and shape manipulation, etc. The word Numpy is short-hand notation for &quot;Numerical Python&quot;.
In this article, you will see how to solve a system of linear equations using Python's Numpy library.
<h2 id="whatisasystemoflinearequations">What is a System of Linear Equations?</h2>
Wikipedia defines a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/System_of_linear_equations">system of linear equations</a> as:
<blockquote>
<blockquote>
In mathematics, a system of linear equations (or linear system) is a collection of two or more linear equations involving the same set of variables.
</blockquote>
</blockquote>
The ultimate goal of solving a system of linear equations is to find the values of the unknown variables. Here is an example of a system of linear equations with two unknown variables, <code>x</code> and <code>y</code>:
Equation 1:
<pre><code class="hljs">4x + 3y = 20
-5x + 9y = 26
</code></pre>
To solve the above system of linear equations, we need to find the values of the <code>x</code> and <code>y</code> variables. There are multiple ways to solve such a system, such as Elimination of Variables, Cramer's Rule, Row Reduction Technique, and the Matrix Solution. In this article we will cover the matrix solution.
In the matrix solution, the system of linear equations to be solved is represented in the form of matrix <code>AX = B</code>. For instance, we can represent Equation 1 in the form of a matrix as follows:
<pre><code class="hljs">A = [[ 4 3]
 [-5 9]]

X = [[x]
 [y]]

B = [[20]
 [26]]
</code></pre>
To find the value of <code>x</code> and <code>y</code> variables in Equation 1, we need to find the values in the matrix <code>X</code>. To do so, we can take the dot product of the inverse of matrix <code>A</code>, and the matrix <code>B</code> as shown below:
<pre><code class="hljs">X = inverse(A).B
</code></pre>
If you are not familiar with how to find the inverse of a matrix, take a look at this link to understand how to manually <a rel="nofollow" target="_blank" href="https://www.mathsisfun.com/algebra/matrix-inverse.html">find the inverse</a> of a matrix. To understand the matrix dot product, check out <a rel="nofollow" target="_blank" href="https://www.mathsisfun.com/algebra/matrix-multiplying.html">this article</a>.
<h2 id="solvingasystemoflinearequationswithnumpy">Solving a System of Linear Equations with Numpy</h2>
From the previous section, we know that to solve a system of linear equations, we need to perform two operations: matrix inversion and a matrix dot product. The Numpy library from Python supports both the operations. If you have not already installed the Numpy library, you can do with the following <code>pip</code> command:
<pre><code class="hljs">$ pip install numpy
</code></pre>
Let's now see how to solve a system of linear equations with the Numpy library.
<h3 id="usingtheinvanddotmethods">Using the inv() and dot() Methods</h3>
First, we will find inverse of matrix <code>A</code> that we defined in the previous section.
Let's first create the matrix <code>A</code> in Python. To create a matrix, the <code>array</code> method of the Numpy module can be used. A matrix can be considered as a list of lists where each list represents a row.
In the following script we create a list named <code>m_list</code>, which further contains two lists: <code>[4,3]</code> and <code>[-5,9]</code>. These lists are the two rows in the matrix <code>A</code>. To create the matrix <code>A</code> with Numpy, the <code>m_list</code> is passed to the <code>array</code> method as shown below:
<pre><code class="hljs">import numpy as np

m_list = [[4, 3], [-5, 9]]
A = np.array(m_list)
</code></pre>
To find the inverse of a matrix, the matrix is passed to the <code>linalg.inv()</code> method of the Numpy module:
<pre><code class="hljs">inv_A = np.linalg.inv(A)

print(inv_A)
</code></pre>
The next step is to find the dot product between the inverse of matrix <code>A</code>, and the matrix <code>B</code>. It is important to mention that matrix dot product is only possible between the matrices if the inner dimensions of the matrices are equal i.e. the number of columns of the left matrix must match the number of rows in the right matrix.
To find the dot product with the Numpy library, the <code>linalg.dot()</code> function is used. The following script finds the dot product between the inverse of matrix <code>A</code> and the matrix <code>B</code>, which is the solution of the Equation 1.
<pre><code class="hljs">B = np.array([20, 26])
X = np.linalg.inv(A).dot(B)

print(X)
</code></pre>
Output:
<pre><code class="hljs">[2. 4.]
</code></pre>
Here, <code>2</code> and <code>4</code> are the respective values for the unknowns <code>x</code> and <code>y</code> in Equation 1. To verify, if you plug <code>2</code> in place of the unknown <code>x</code> and <code>4</code> in the place of the unknown <code>y</code> in equation <code>4x + 3y</code>, you will see that the result will be 20.
Let's now solve a system of three linear equations, as shown below:
<pre><code class="hljs">4x + 3y + 2z = 25
-2x + 2y + 3z = -10
3x -5y + 2z = -4
</code></pre>
The above equation can be solved using the Numpy library as follows:
Equation 2:
<pre><code class="hljs">A = np.array([[4, 3, 2], [-2, 2, 3], [3, -5, 2]])
B = np.array([25, -10, -4])
X = np.linalg.inv(A).dot(B)

print(X)
</code></pre>
In the script above the <code>linalg.inv()</code> and the <code>linalg.dot()</code> methods are chained together. The variable <code>X</code> contains the solution for Equation 2, and is printed as follows:
<pre><code class="hljs">[ 5. 3. -2.]
</code></pre>
The value for the unknowns <code>x</code>, <code>y</code>, and <code>z</code> are 5, 3, and -2, respectively. You can plug these values in Equation 2 and verify their correctness.
<h3 id="usingthesolvemethod">Using the solve() Method</h3>
In the previous two examples, we used <code>linalg.inv()</code> and <code>linalg.dot()</code> methods to find the solution of system of equations. However, the Numpy library contains the <code>linalg.solve()</code> method, which can be used to directly find the solution of a system of linear equations:
<pre><code class="hljs">A = np.array([[4, 3, 2], [-2, 2, 3], [3, -5, 2]])
B = np.array([25, -10, -4])
X2 = np.linalg.solve(A,B)

print(X2)
</code></pre>
Output:
<pre><code class="hljs">[ 5. 3. -2.]
</code></pre>
You can see that the output is same as before.
<h3 id="arealworldexample">A Real-World Example</h3>
Let's see how a system of linear equation can be used to solve real-world problems.
Suppose, a fruit-seller sold 20 mangoes and 10 oranges in one day for a total of $350. The next day he sold 17 mangoes and 22 oranges for $500. If the prices of the fruits remained unchanged on both the days, what was the price of one mango and one orange?
This problem can be easily solved with a system of two linear equations.
Let's say the price of one mango is <code>x</code> and the price of one orange is <code>y</code>. The above problem can be converted like this:
<pre><code class="hljs">20x + 10y = 350
17x + 22y = 500
</code></pre>
The solution for the above system of equations is shown here:
<pre><code class="hljs">A = np.array([[20, 10], [17, 22]])
B = np.array([350, 500])
X = np.linalg.solve(A,B)

print(X)
</code></pre>
And here is the output:
<pre><code class="hljs">[10. 15.]
</code></pre>
The output shows that the price of one mango is $10 and the price of one orange is $15.
<h2 id="conclusion">Conclusion</h2>
The article explains how to solve a system of linear equations using Python's Numpy library. You can either use <code>linalg.inv()</code> and <code>linalg.dot()</code> methods in chain to solve a system of linear equations, or you can simply use the <code>solve()</code> method. The <code>solve()</code> method is the preferred way.

Guest Contributor

Two or more linear equations with the same set of variables are called a system of linear equations. We can solves for those variables in Python with Numpy.