How to Speed Up Python Read From Disk

Python might be one of today's virtually popular programming languages, but it's definitely not the nearly efficient. In the machine learning world in detail, practitioners sacrifice efficiency for the ease-of-use that Python offers.

That doesn't mean that you tin can't speed things up in other ways. Cython is an easy fashion to significantly lessen computation fourth dimension of Python scripts, without sacrificing the functionality hands achieved using Python.

This tutorial will innovate you to using Cython to speed up Python scripts. We'll wait at a simple yet computationally expensive task: creating a for loop that iterates through a Python list of 1 billion numbers, and sums them. Since time is peculiarly of import when running code on resources-limited devices, we'll put this issue into context by considering how to implement Python code in Cython on Raspberry Pi (RPi). Cython makes a significant change in the speed of adding. Remember of it similar a sloth compared to a cheetah.

Sloth prototype from IndiaToday | Cheetah epitome from Pixabay

The sections covered in this tutorial are as follows:

• Python, CPython, and Cython
• Cythonizing Simple Python Code
• Cythonizing a for Loop
• Assigning C Data Types to the Variables
• Using Cython in Raspberry Pi

Let'southward get started.

Bring this project to life

Python and CPython

Many people are unaware of the fact that languages like Python are actually implemented in other languages. For example, the C implementation of Python is chosen CPython. Note that it is non Cython. For more information almost the unlike implementations of Python, you tin read this post.

The default and about popular implementation of Python is CPython. There is an important reward of using it. C is a compiled language and its code is converted into machine code, which is executed directly by the central processing unit of measurement (CPU). Now y'all may wonder, if C is a compiled language, does that mean Python is too?

Python implementation in C (CPython) is non 100% complied, and also non 100% interpreted. There is both compilation and interpretation in the process of running a Python script. To make this clear, permit'south meet the steps of running a Python script:

1. Compiling source code using CPython to generate bytecode
2. Interpreting the bytecode in a CPython interpreter
3. Running the output of the CPython interpreter in a CPython virtual motorcar

Compilation takes place when CPython compiles the source code (.py file) to generate the CPython bytecode (.pyc file). The CPython bytecode (.pyc file) is then interpreted using a CPython interpreter, and the output runs in a CPython virtual machine. According to the above steps, the process of running a Python script involves both compilation and interpretation.

The CPython compiler generates the bytecode just once, but the interpreter is called each fourth dimension the code runs. Usually the interpretation of the bytecode takes a lot of time. If using an interpreter slows downwards the execution, why use it at all? The big reason is that it helps make Python cross-platform. Since the bytecode runs in a CPython virtual machine on top of the CPU, it is independent of the auto it's running on. Every bit a result, the bytecode tin can run in different machines unchanged.

If there is no interpreter used, then the CPython compiler will generate car code that straight runs in the CPU. Because different platforms have unlike instructions, the code will not be cross-platform.

In summary, using a compiler speeds upwardly the process but an interpreter makes the code cross-platform. So, a reason why Python is slower than C is that an interpreter is used. Remember that the compiler just runs once merely the interpreter runs each time the code is executed.

Python is much slower than C, merely many programmers still prefer it since it's and so much easier to utilize. Python hides many details from the programmer, which can help prevent frustrating debugging. For instance, since Python is a dynamically-typed language you exercise non take to explicitly specify the blazon of each variable in your lawmaking – Python will deduce it automatically. In contrast, with statically-typed languages (similar C, C++ or Java) yous must specify the types of the variables, as seen beneath.

          int x = 10 string s = "How-do-you-do"        

Compare this to the implementation below in Python. Dynamic typing makes it easier to code, but adds much more burden on the machine to notice the suitable datatype. This makes the process slower.

          x = 10 s = "Hello"        

Generally speaking, "higher level" languages like Python are much easier to use for developers. However, when the code is run it will demand to be converted into low-level instructions. This conversion takes more time, which is sacrificed for ease-of-use.

If fourth dimension is an important factor, and so you need to use the lower-level instructions. So rather than typing the code using Python, which is the interface, you tin can write it using CPython which is the backend of Python implemented in C. However, if y'all do and so you will feel that yous are programming in C, non Python.

CPython is much more complex. In CPython, everything is implemented in C. At that place is no mode to escape the C complexity in coding. This is why many developers opt for Cython instead. But how is Cython dissimilar from CPython?

How Cython Is Different

According to the Cython documentation, Cython is Python with C information types. Another definition from the Cython tutorial 2009 paper clarifies:

Cython is a programming language based on Python with extra syntax to provide static blazon declarations. This takes advantage of the benefits of Python while allowing one to reach the speed of C.

According to the above definitions, Cython is a language which lets you accept the all-time of both worlds – speed and ease-of-utilise. Yous tin still write regular code in Python, only to speed things upwardly at run time Cython allows you to replace some pieces of the Python code with C. Then, you end upward mixing both languages together in a single file. Note that you can imagine that everything in Python is valid in Cython, but with some limitations. For more info about the limitations, y'all tin visit this page.

The regular Python file has a .py extension, simply the Cython file has the .pyx extension instead. The aforementioned Python code can exist written inside the .pyx files, but these let you to also use Cython code. Notation that merely placing the Python code into a .pyx file may speed upward the process compared to running the Python code directly, but not equally much as when besides declaring the variable types. Thus, the focus of this tutorial is non only on writing the Python lawmaking within the .pyx file merely also on making edits which will make it run faster. By doing so we add a scrap of difficulty to the programming, but much time is saved from doing then. If you take any experience with C programming, then it will be even easier for you.

Cythonizing Simple Python Code

To brand your Python into Cython, commencement you lot need to create a file with the .pyx extension rather than the .py extension. Inside this file, yous can offset past writing regular Python code (note that there are some limitations in the Python code accepted by Cython, equally clarified in the Cython docs).

Before going forward, make certain Cython is installed. You tin practise and so with the following command.

          pip install cython        

To generate the .pyd/.so file we need to start build the Cython file. The .pyd/.so file represents the module to be imported later. To build the Cython file, a setup.py file will be used. Create this file and place the lawmaking below within information technology. We'll use the distutils.core.setup() function to call the Cython.Build.cythonize() function, which will cythonize the .pyx file. This office accepts the path of the file yous want to cythonize. Here I'm assuming that the setup.py file is placed in the same location as the test_cython.pyx file.

          import distutils.core import Cython.Build distutils.core.setup(     ext_modules = Cython.Build.cythonize("test_cython.pyx"))        

In gild to build the Cython file, issue the command below in the command prompt. The current directory of the command prompt is expected to be the same as the directory of the setup.py file.

          python setup.py build_ext --inplace        

After this command completes, 2 files will be placed beside the .pyx file. The first one has the .c extension and the other file volition have the extension .pyd (or similar, based on the operating system used). In order to use the generated file, just import the test_cython module and the "How-do-you-do Cython" message will appear directly, as you lot see beneath.

We have now successfully cythonized the Python code. The side by side department discusses cythonizing a .pyx file in which  loop is created.

Cythonizing a "for" Loop

Now let'south optimize our aforementioned chore: a for loop that iterates through ane million numbers and sums them. Let'southward kickoff by looking at the efficiency of just the iterations of the loop. The time module is imported for estimating how long information technology takes to execute.

          import time t1 = time.time()  for k in range(1000000):     laissez passer  t2 = fourth dimension.time() t = t2-t1 print("%.20f" % t)        

In a .pyx file, the hateful fourth dimension for 3 runs is 0.0281 seconds. The code is running on a machine with Cadre i7-6500U CPU @ 2.5 GHz and xvi GB DDR3 RAM.

Compare this with the time information technology takes to run in a normal Python file, the mean of which is 0.0411 seconds. This ways Cython is 1.46 times faster than Python for the iterations lonely, even though we don't need to alter the for loop to get information technology to execute at C-speed.

Now allow'southward add together the summing chore. We'll use the range() role for this.

          import fourth dimension t1 = fourth dimension.fourth dimension()  total = 0 for k in range(1000000):     full = total + yard print "Total =", total  t2 = fourth dimension.time() t = t2-t1 print("%.100f" % t)        

Note that both of the scripts return the same value, which is 499999500000. In Python this takes an boilerplate of 0.1183 seconds to run (betwixt 3 trials). In Cython it is 1.35 times faster, at an average of 0.0875 seconds.

Let's encounter another example in which the loop iterates through ane billion number starting from 0.

          import time t1 = time.time()  total = 0 for k in range(1000000000):     total = total + g print "Full =", total  t2 = time.time() t = t2-t1 print("%.20f" % t)        

The Cython script completed in nigh 85 seconds (1.4 minutes) while the Python script completed in nearly 115 seconds (i.ix minutes). In both cases it's just besides much time. What is the benefit of using Cython if information technology lasts for more than a minute on such a niggling chore? Annotation that this is our mistake, not Cython'due south.

As discussed previously, writing the Python code within the Cython .pyx script is an comeback, merely it does not brand a very big cut in the execution time. We have to make edits to the Python code within the Cython script. The outset matter to focus on is to explicitly ascertain the data types of the variables used.

Assigning C Data Types to Variables

According to the previous code, there are 5 variables used: full, k, t1, t2, and t. All of these variables have their data types deduced implicitly by the code, thus taking more fourth dimension. To save the time used for deducing their data types, let's assign their data types from the C linguistic communication instead.

The type of the total variable is unsigned long long int. Information technology is an integer because the sum of all numbers is an integer, and it is unsigned because the sum will be positive. But why information technology is long long? Considering the sum of all numbers is very large, long long is added to increase the variable size to the maximum possible size.

The type defined for the variable yard is int, and the float blazon is assigned for the remaining iii variables t1, t2, and t.

          import time  cdef unsigned long long int total cdef int k cdef float t1, t2, t  t1 = fourth dimension.time()  for 1000 in range(1000000000):     total = total + k impress "Total =", total  t2 = time.time() t = t2-t1 impress("%.100f" % t)        

Note that the precision divers in the last impress statement is set to 100, and all of these numbers are zeros (run across the next figure). This is what we can await from using Cython. While Python takes more than one.9 minutes, Cython takes no time at all. I cannot even say that the speed is 1000 or 100000 faster than Python; I tried different precisions for the printed fourth dimension, and still no number appears.

Note that yous can also create an integer variable for property the value passed to the range() function. This will boost operation even more. The new lawmaking is listed below, where the value is stored in the maxval integer variable.

          import time  cdef unsigned long long int maxval cdef unsigned long long int total cdef int k cdef float t1, t2, t  maxval=1000000000  t1=fourth dimension.time()  for yard in range(maxval):     total = full + g print "Total =", full  t2=time.time() t = t2-t1 impress("%.100f" % t)        

Now that we've seen how to speed up the performance of the Python scripts by using Cython, let's apply this to Raspberry Pi (RPi).

Accessing Raspberry Pi from PC

If this is the showtime time you're using your Raspberry Pi, then both your PC and the RPi need to go continued over a network. You can do this by connecting both of them to a switch in which the DHCP (Dynamic Host Configuration Protocol) is active to assign them IP addresses automatically. After successful network creation, you tin admission the RPi based on the IPv4 address assigned to it. How practice you know what the IPv4 address assigned to your RPi is? Don't worry, you can but use an IP scanner tool. In this tutorial, I will utilise a free application chosen Avant-garde IP Scanner.

The interface of the awarding is as seen below. Information technology accepts a range of IPv4 addresses to search for, and returns the information for active devices.

You need to enter the range of IPv4 addresses in your local network. If yous do non know the range, but issue the ipconfig command in Windows (or ifconfig in Linux) to know your PC IPv4 address (as shown in the figure beneath). In my case, the IPv4 accost assigned to the Wi-Fi adapter of my PC is 192.168.43.177 and the subnet mask is 255.255.255.0. This means that the range of IPv4 addresses in the network is from 192.168.43.1 to 192.168.43.255. Co-ordinate to the figure, the IPv4 address 192.168.43.1 is assigned to the gateway. Note that the concluding IPv4 address in the range, 192.168.43.255, is reserved for circulate messages. Thus, the range to search should start from 192.168.43.2 and end at 192.168.43.254.

According to the result of the scan shown in the side by side figure, the IPv4 accost assigned to the RPi is 192.168.43.63. This IPv4 address can be used to create a secure beat out (SSH) session.

For establishing the SSH session, I will apply a free software called MobaXterm. The interface of the application is as follows.

In lodge to create an SSH session, simply click on the Session push at the peak-left corner. A new window appears every bit shown below.

From this window, click on the SSH button at the meridian-left corner to open the window shown beneath. Simply enter the IPv4 address of the RPi and the username (which is by default pi), then click OK to commencement the session.

Later on clicking the OK button, a new window appears asking for the password. The default countersign is raspberrypi. After logging in, the adjacent window appears. The pane to the left helps to navigate the directories of the RPi hands. There is besides a command-line for entering commands.

Using Cython with Raspberry Pi

Create a new file and ready its extension to .pyx for writing the code of the concluding case. There are options in the bar at the left pane for creating new files and directories. You tin can use the new file icon to brand things even simpler, as shown in the following figure. I created a file named test_cython.pyx in the root directory of the RPi.

Just double-click the file to open it, paste the code, and save it. After that we tin create the setup.py file, which is exactly the same every bit nosotros discussed previously. Adjacent nosotros must consequence the following command for building the Cython script.

          python3 setup.py build_ext --inplace        

After this command completes successfully, you can find the output files listed in the left pane according to the adjacent figure. Note that the extension of the module to be imported is at present .then, every bit we are no longer using Windows.

At present permit's actuate Python and import the module, as shown below. The same results achieved on the PC are too achieved hither; the consumed time is essentially zero.

Conclusion

This tutorial discussed how to use Cython to reduce the computation time of executing Python scripts. We looked at the example of using a for loop to sum all elements in a Python list of i billion numbers, and compared its time for execution with and without declaring the variable types. While this takes nearly two minutes to run in pure Python, it takes essentially no fourth dimension to run with static variables declared using Cython.

In the next tutorial nosotros'll replace this Python listing with a NumPy assortment, and run into how we can optimize NumPy array processing using Cython. Then we'll look at how to cythonize more advanced Python scripts, such every bit genetic algorithms. This are great ways to hands enhance the efficiency of your machine learning projects.

vegabactithe.blogspot.com

Source: https://blog.paperspace.com/boosting-python-scripts-cython/

Share this post