<h2 id="introduction">Introduction</h2>
To work with stored data, file handling becomes the core knowledge of every professional Python programmer. Right from its earliest release, both reading and writing data to files are built-in Python features. In comparison to other programming languages like C or Java, it is pretty simple and only requires a few lines of code. Furthermore, no extra module has to be loaded to do that properly.
<blockquote>
In this article we will be explaining how to read files with Python through examples. Some examples include reading a file line-by-line, as a chunk (a defined number of lines at a time), and reading a file in one go. Also, we will show you a way to read a specific line from the file, only, without searching the entire file.
</blockquote>
<h2 id="basicsoffilesinpython">Basics of Files in Python</h2>
The common methods to operate with files are <code>open()</code> to open a file, <code>seek()</code> to set the file's current position at the given offset, and <code>close()</code> to close the file object when you're done using it. The built-in <code>open()</code> function returns a file handle that represents a file object to be used to access the file for reading, writing, or appending.
When opening a file for reading, Python needs to know exactly how the file should be opened with the system. Two access modes are available - reading and reading in binary mode. The respective flags used are <code>'r'</code>, and <code>'rb'</code>, and have to be specified when opening a file with the built-in <code>open()</code> function. The first mode includes the interpretation of special characters like &quot;CR&quot; (carriage return) and &quot;LF&quot; (linefeed) to represent line breaks, whereas the binary mode allows you to read the data in raw mode - where the data is stored as is without further interpretation.
Once you've opened a file, the <code>open()</code> function will return a file object to you. These file objects have methods like <code>read()</code>, <code>readline()</code>, <code>write()</code>, <code>tell()</code>, and <code>seek()</code>. While some file objects (or file-like objects) have more methods than those listed here, these are the most common. Not all file objects need to implement all of the file methods.
<h2 id="readingafilelinebyline">Reading a File Line-by-Line</h2>
The first example is inspired by the two programming languages - C and C++. It is probably the most intuitive approach - open the file using the <code>open()</code> function, <a target="_blank" href="https://stackabuse.com/read-a-file-line-by-line-in-python/">read the file line-by-line</a> using the <code>readline()</code> method, and output the line immediately after reading.
In use here is a <code>while</code> loop that continuously reads from the file as long as the <code>readline()</code> method keeps returning data. In case the end of file (EOF) is reached the <code>while</code> loop stops and the file object is closed, freeing up the resources for other programs to use:
<pre><code class="hljs"># Define the name of the file to read from
filename = &quot;test.txt&quot;

# Open the file for reading
filehandle = open(filename, &#x27;r&#x27;)

while True:
 # read a single line
 line = filehandle.readline()
 if not line:
 break
 print(line)

# Close the pointer to that file
filehandle.close()
</code></pre>
As you may have noted, we have explicitly opened and closed the file in this example. Although the Python interpreter closes the opened files automatically at the end of the execution of the Python program, explicitly closing the file via <code>close()</code> is a good programming style, and should not be forgotten.
As an improvement, the convenient iterator protocol was introduced in Python 2.3. This allows you to simplify the <code>readline</code> loop:
<pre><code class="hljs"># Define the name of the file to read from
filename = &quot;test.txt&quot;

for line in open(filename, &#x27;r&#x27;):
 print(line)
</code></pre>
In use here is a <code>for</code> loop in combination with the <code>in</code> iterator. The current line is identified with the help of the <code>in</code> iterator, read from the file, and its content is output to <code>stdout</code>. Python covers the opening and closing of the file for you when it falls out of scope. While inefficient, this allows you to not have to deal with file handles anymore.
Unfortunately, the code above is less explicit and relies on Python's internal garbage collection to handle closing the file.
Introduced in Python 2.5, the <code>with</code> command encapsulates the entire process even more, and also handles opening and closing files just once throughout the scoped code block:
<pre><code class="hljs"># Define the name of the file to read from
filename = &quot;test.txt&quot;

with open(filename, &#x27;r&#x27;) as filehandle:
 for line in filehandle:
 print(line)
</code></pre>
The combination of the <code>with</code> statement and the <code>open()</code> command opens the file only once. If successful the <code>for</code> loop is executed, and the content of the line is printed on <code>stdout</code>.
Furthermore, the usage of the <code>with</code> statement has a side effect. Internally, the Python interpreter creates a <code>try</code>-<code>finally</code>-block to encapsulate reading from the file. The following example shows what is essentially happening internally in Python with the <code>with</code> code blocks:
<pre><code class="hljs">try:
 filehandle = open(filename, &#x27;r&#x27;)
 # Do something...
finally:
 filehandle.close()
</code></pre>
<h2 id="readingafileaschunksoflines">Reading a File as Chunks of Lines</h2>
Up to now, we have processed a file line by line. This is rather slow for huge files and can be improved by reading multiple lines at the same time. To achieve that, the <code>islice()</code> method from the <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/itertools.html">itertools</a> module comes into play. Also, it works as an iterator and returns a chunk of data that consists of <code>n</code> lines. At the end of the file, the result might be shorter, and finally, the call will return an empty list:
<pre><code class="hljs">from itertools import islice

# Define the name of the file to read from
filename = &quot;test.txt&quot;

# Define the number of lines to read
number_of_lines = 5

with open(filename, &#x27;r&#x27;) as input_file:
 lines_cache = islice(input_file, number_of_lines)
 
 for current_line in lines_cache:
 print (current_line)
</code></pre>
<h2 id="readingaspecificlinefromafile">Reading a Specific Line from a File</h2>
Using the methods shown above we can also perform other useful actions, like reading a specific line from a file. To do this, we make use of a counter and print the appropriate line when we come to it while iterating through the file:
<pre><code class="hljs"># Define the name of the file to read from
filename = &quot;test.txt&quot;

# Define the line number
line_number = 3

print (f&quot;line {line_number} of {filename} is: &quot;)

with open(filename, &#x27;r&#x27;) as filehandle:
current_line = 1
 for line in filehandle:
 if current_line == line_number:
 print(line)
 break
 current_line += 1
</code></pre>
This should be simple to understand, but it's a bit longer than the previous examples. It can be shortened using the <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/linecache.html">linecache</a> module.
The following example shows how to simplify the code using the <code>getline()</code> method. If the requested line number falls out of the range of valid lines in the file, then the <code>getline()</code> method returns an empty string instead:
<pre><code class="hljs">import linecache

# Define the name of the file to read from
filename = &quot;test.txt&quot;

# Define line_number
line_number = 3

# Retrieve specific line
line = linecache.getline(filename, line_number)

print (f&quot;line {line_number} of {filename}:&quot;)
print (line)
</code></pre>
<h2 id="readingtheentirefileatonce">Reading the Entire File at Once</h2>
Last but not least we will have a look at a very different case than the previous example - reading an entire file in one go.
Keep in mind that in most cases you should have enough memory to read the entire file, since characters don't take up too much space, but be weary of large files. The following example uses a combination of the <code>with</code> statement, and the <code>read()</code> method. In this case, we'll use <code>read()</code> to load the file content as a data stream:
<pre><code class="hljs"># Define the name of the file to read from
filename = &quot;test.txt&quot;

with open(filename, &#x27;r&#x27;) as filehandle:
 filecontent = filehandle.read()
 print (filecontent)
</code></pre>
Python also offers the <code>readlines()</code> method, which is similar to the <code>readline()</code> method from the first example. In contrast to <code>read()</code>, the file content is stored in a list, where each line of the content is an item:
<pre><code class="hljs"># Define the name of the file to read from
filename = &quot;test.txt&quot;

with open(filename, &#x27;r&#x27;) as filehandle:
 filecontent = filehandle.readlines()
 for line in filecontent:
 print (line)
</code></pre>
While <code>readlines()</code> will read content from the file until it hits EOF, keep in mind that you can also limit the amount of content read by providing the <code>sizehint</code> parameter, which is the number of bytes to read.
<h2 id="conclusion">Conclusion</h2>
As usual, there is more than one way to read the contents of a file. In terms of speed, all of them are more or less in the same category. Which solution works best for you depends on your specific use case. We think it is quite helpful to see what is possible and then to choose the solution that suits best.
While Python greatly simplifies the process of reading files, it can still become tricky at times, in which case I'd recommend you take a look at the <a rel="nofollow" target="_blank" href="https://docs.python.org/3/tutorial/inputoutput.html">official Python documentation</a> for more info.

Frank Hofmann

Dimitrije Stamenic

In this short guide - learn how to read files in Python, using the seek(), open(), close(), read(), readlines(), etc. methods. You can read an entire file, a specific line (without searching through the entire file), read it line by line or a as a chunk of text between line indices.

Reading Files with Python

<h2 id="introduction">Introduction</h2>
Python programmers intensively use arrays, lists, and dictionaries as serialized data structures. Storing these data structures persistently requires either a file or a database to properly work.
<blockquote>
In this article, we'll take a look at how to write a list to file, and how to read that list back into memory.
</blockquote>
To <a target="_blank" href="https://stackabuse.com/writing-files-using-python/">write data in a file</a>, and to <a target="_blank" href="https://stackabuse.com//reading-files-with-python/">read data from a file</a>, the Python programming language offers the standard methods <code>write()</code> and <code>read()</code> for dealing with a single line, as well as <code>writelines()</code> and <code>readlines()</code> for dealing with multiple lines. Furthermore, both the <code>pickle</code> and the <code>json</code> modules allow clever ways of dealing with serialized data sets as well.
<h2 id="usingthereadandwritemethods">Using the read() and write() Methods</h2>
To deal with characters (strings) the basic <code>read()</code> and <code>write()</code> methods work excellently. Saving such a list line by line into the file <code>listfile.txt</code> can be done as follows:
<pre><code class="hljs"># Define a list of places
places = [&#x27;Berlin&#x27;, &#x27;Cape Town&#x27;, &#x27;Sydney&#x27;, &#x27;Moscow&#x27;]

with open(&#x27;listfile.txt&#x27;, &#x27;w&#x27;) as filehandle:
 for listitem in places:
 filehandle.write(f&#x27;{listitem}\n&#x27;)
</code></pre>
The <code>listitem</code> is extended by a line break <code>&quot;\n&quot;</code>, firstly, and then stored into the output file. Now we can take a look at how to read the entire list from the file <code>listfile.txt</code> back into memory:
<pre><code class="hljs"># Define an empty list
places = []

# Open the file and read the content in a list
with open(&#x27;listfile.txt&#x27;, &#x27;r&#x27;) as filehandle:
 for line in filehandle:
 # Remove linebreak which is the last character of the string
 curr_place = line[:-1]
 # Add item to the list
 places.append(curr_place)
</code></pre>
Keep in mind that you'll need to remove the line break from the end of the string. In this case, it helps us that Python allows list operations on strings, too. This removal is simply done as a list operation on the string itself, which keeps everything but the last element. This element contains the character <code>&quot;\n&quot;</code> that represents the line break on UNIX/Linux systems.
<h2 id="usingthewritelinesandreadlinesmethods">Using the writelines() and readlines() Methods</h2>
As mentioned at the beginning of this article, Python also contains the two methods - <code>writelines()</code> and <code>readlines()</code> - to write and read multiple lines in one step, respectively. Let's write the entire list to a file on disk:
<pre><code class="hljs"># Define a list of places
places_list = [&#x27;Berlin&#x27;, &#x27;Cape Town&#x27;, &#x27;Sydney&#x27;, &#x27;Moscow&#x27;]

with open(&#x27;listfile.txt&#x27;, &#x27;w&#x27;) as filehandle:
 filehandle.writelines(f&quot;{place for place in places_list}\n&quot;)
</code></pre>
To read the entire list from a file on disk we need to:
<pre><code class="hljs"># Define an empty list
places = []

# Open the file and read the content in a list
with open(&#x27;listfile.txt&#x27;, &#x27;r&#x27;) as filehandle:
 filecontents = filehandle.readlines()
 for line in filecontents:
 # Remove linebreak which is the last character of the string
 curr_place = line[:-1]
 # Add item to the list
 places.append(curr_place)
</code></pre>
The code above follows a more traditional approach borrowed from other programming languages. Let's write it in a more Pythonic way:
<pre><code class="hljs"># Define an empty list
places = []

# Open the file and read the content in a list
with open(&#x27;listfile.txt&#x27;, &#x27;r&#x27;) as filehandle:
 places = [current_place.rstrip() for current_place in filehandle.readlines()]
</code></pre>
Firstly, the file content is read via <code>readlines()</code>. Secondly, in a <code>for</code> loop from each line the line break character is removed using the <code>rstrip()</code> method. Thirdly, the string is added to the list of places as a new list item.
In comparison with the listing before the code is much more compact, but may be more difficult to read for beginner Python programmers.
<h2 id="usingthejoblibmodule">Using the Joblib Module</h2>
The initial methods explained up to now store the list in a way that humans can still read it - quite literally a sequential list in a file. This is great for creating simple reports or outputting export files for users to further use, such as CSV files. However - if your aim is to just serialize a list into a file, that can be loaded later, there's no need to store it in a human-readable format.
The <code>joblib</code> module provides the easiest way to dump a Python object (can be any object really):
<pre><code class="hljs">import joblib

places = [&#x27;Berlin&#x27;, &#x27;Cape Town&#x27;, &#x27;Sydney&#x27;, &#x27;Moscow&#x27;]
# Dumps into file
joblib.dump(places, &#x27;places.sav&#x27;)
# Loads from file
places = joblib.load(&#x27;places.sav&#x27;)
print(places) # [&#x27;Berlin&#x27;, &#x27;Cape Town&#x27;, &#x27;Sydney&#x27;, &#x27;Moscow&#x27;]
</code></pre>
<code>joblib</code> remains the simplest and cleanest way to serialize objects in an efficient format, and load them later. You can use any arbitrary format, such as <code>.sav</code>, <code>.data</code>, etc. It doesn't really matter - both <code>joblib</code> and alternatives like <code>pickle</code> will read the files just fine.
<h2 id="usingthepicklemodule">Using the pickle Module</h2>
As an alternative to <code>joblib</code>, we can use <code>pickle</code>! Its <code>dump()</code> method stores the list efficiently as a binary data stream. Firstly, the output file <code>listfile.data</code> is opened for binary writing (<code>&quot;wb&quot;</code>). Secondly, the list is stored in the opened file using the <code>dump()</code> method:
<pre><code class="hljs">import pickle

places = [&#x27;Berlin&#x27;, &#x27;Cape Town&#x27;, &#x27;Sydney&#x27;, &#x27;Moscow&#x27;]

with open(&#x27;listfile.data&#x27;, &#x27;wb&#x27;) as filehandle:
 # Store the data as a binary data stream
 pickle.dump(places, filehandle)
</code></pre>
As the next step, we read the list from the file as follows. Firstly, the output file <code>listfile.data</code> is opened binary for reading (<code>&quot;rb&quot;</code>). Secondly, the list of places is loaded from the file using the <code>load()</code> method:
<pre><code class="hljs">import pickle

with open(&#x27;listfile.data&#x27;, &#x27;rb&#x27;) as filehandle:
 # Read the data as a binary data stream
 placesList = pickle.load(filehandle)
</code></pre>
The two examples here demonstrate the usage of strings. Although, <code>pickle</code> works with all kinds of Python objects such as strings, numbers, self-defined structures, and every other built-in data structure Python provides.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: For a detailed guide on pickling objects in general, read our <a href="https://stackabuse.com/how-to-pickle-and-unpickle-objects-in-python/">&quot;How to Pickle and Unpickle Objects in Python&quot;</a>!

 </div>
 </div>
 </div>
 <h2 id="usingthejsonformat">Using the JSON Format</h2>
The binary data format <code>pickle</code> uses is specific to Python. To improve the interoperability between different programs the JavaScript Object Notation (<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/JSON">JSON</a>) provides an easy-to-use and human-readable schema, and thus became very popular for serializing files and sharing them over APIs.
The following example demonstrates how to write a list of mixed variable types to an output file using the <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/json.html">json</a> module. Having opened the output file for writing, the <code>dump()</code> method stores the basic list in the file using the JSON notation:
<pre><code class="hljs">import json

# Define list with values
basic_list = [1, &quot;Cape Town&quot;, 4.6]

# Open output file for writing
with open(&#x27;listfile.txt&#x27;, &#x27;w&#x27;) as filehandle:
 json.dump(basic_list, filehandle)
</code></pre>
Reading the contents of the output file back into memory is as simple as writing the data. The corresponding method to <code>dump()</code> is named <code>load()</code>:
<pre><code class="hljs">import json

# Open output file for reading
with open(&#x27;listfile.txt&#x27;, &#x27;r&#x27;) as filehandle:
 basic_list = json.load(filehandle)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Different methods we've shown above range from simple writing/reading data up to dumping/loading data via binary streams using pickle and JSON. This simplifies storing a list persistently and reading it back into memory.

In this article, we'll take a look at how to write a list to file, and how to read that list back into memory. We'll be using read()7write() and readlines()/writelines() functions, pickle module, as well as the JSON data format. 

Reading and Writing Lists to a File in Python

David Landup

Cássia Sampaio

Logistic regression is sometimes confused with linear regression - due to sharing the term regression, but it is far different from it. While linear regression predicts continuous values, making it a regression algorithm, logistic regression predicts discrete values, making it a classification algorithm. In this guide, we'll dive deeper into Python implementation of the logistic regression using Scikit-Learn and other useful Python libraries.

Definitive Guide to Logistic Regression in Python

<h2 id="introduction">Introduction</h2>
Object detection is a large field in computer vision, and one of the more important applications of computer vision &quot;in the wild&quot;. From it, keypoint detection (oftentimes used for pose estimation) was extracted.
Object detection and keypoint detection aren't as standardized as image classification, mainly because most of the new developments are typically done by individual researchers, maintainers and developers, rather than large libraries and frameworks. It's difficult to package the necessary utility scripts in a framework like TensorFlow or PyTorch and maintain the API guidelines that guided the development so far.
This makes object detection somewhat more complex, typically more verbose (but not always), and less approachable than image classification.
Fortunately for the masses - Ultralytics has developed a simple, very powerful and beautiful object detection API around their YOLOv5 which has been extended by other research and development teams into newer versions, such as YOLOv7.
<blockquote>
In this short guide, we'll be performing Pose Estimation (Keypoint Detection) in Python, with state-of-the-art YOLOv7.
</blockquote>
Keypoints can be various points - parts of a face, limbs of a body, etc. Pose estimation is a special case of keypoint detection - in which the points are parts of a human body, and can be used to replace expensive position tracking hardware, enable over-the-air robotics control, and power a new age of human self expression through AR and VR.
<h2 id="yoloandposeestimation">YOLO and Pose Estimation</h2>
YOLO (You Only Look Once) is a methodology, as well as family of models built for object detection. Since the inception in 2015, YOLOv1, YOLOv2 (YOLO9000) and YOLOv3 have been proposed by the same author(s) - and the deep learning community continued with open-sourced advancements in the continuing years.
<a target="_blank" rel="nofollow noopener noreferrer" href="https://github.com/ultralytics/yolov5">Ultralytics' YOLOv5</a> is the first large-scale implementation of YOLO in PyTorch, which made it more accessible than ever before, but the main reason YOLOv5 has gained such a foothold is also the beautifully simple and powerful API built around it. The project abstracts away the unnecessary details, while allowing customizability, practically all usable export formats, and employs amazing practices that make the entire project both efficient and as optimal as it can be.
YOLOv5 is still the staple project to build Object Detection models with, and many repositories that aim to advance the YOLO method start with YOLOv5 as a baseline and offer a similar API (or simply fork the project and build on top of it). Such is the case of <a rel="nofollow noopener noreferrer" target="_blank" href="https://arxiv.org/abs/2105.04206">YOLOR (You Only Learn One Representation)</a> and YOLOv7 which built on top of YOLOR (same author) which is the latest advancement in the YOLO methodology.
YOLOv7 isn't just an object detection architecture - it provides new model heads that can output keypoints (skeletons) and perform instance segmentation besides only bounding box regression, which wasn't standard with previous YOLO models. This isn't surprising, since many object detection architectures were re-purposed for instance segmentation and keypoint detection tasks earlier as well, due to the shared general architecture, with different outputs depending on the task. Even though it isn't surprising - supporting instance segmentation and keypoint detection will likely become the new standard for YOLO-based models, which have begun outperforming practically all other two-stage detectors a couple of years ago.
<blockquote>
This makes instance segmentation and keypoint detection faster to perform than ever before, with a simpler architecture than two-stage detectors.
</blockquote>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 YOLOv7 was released alongside a paper named <a rel="nofollow noopener noreferrer" target="_blank" href="https://arxiv.org/abs/2207.02696">&quot;YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors&quot;</a>, and the source code is available <a rel="nofollow noopener noreferrer" target="_blank" href="https://github.com/WongKinYiu/yolov7">on GitHub</a>.

 </div>
 </div>
 </div>
 The model itself was created through architectural changes, as well as optimizing aspects of training, dubbed &quot;bag-of-freebies&quot;, which increased accuracy without increasing inference cost.
<h2 id="installingyolov7">Installing YOLOv7</h2>
Let's go ahead and install the project from GitHub:
<pre><code class="hljs">! git clone https://github.com/WongKinYiu/yolov7.git
</code></pre>
This creates a <code>yolov7</code> directory under your current working directory, in which you'll be able to find the basic project files:
<pre><code class="hljs">%cd yolov7
!ls

/Users/macbookpro/jup/yolov7
LICENSE.md detect.py models tools
README.md export.py paper train.py
cfg figure requirements.txt train_aux.py
data hubconf.py scripts utils
deploy inference test.py
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: When calling <code>!cd dirname</code>, it's only applied to that cell. When calling <code>%cd dirname</code>, it's remembered for all subsequent cells as well.

 </div>
 </div>
 </div>
 Whenever you run code with a given set of weights - they'll be downloaded and stored in this directory. To perform pose estimation, we'll want to download the weights for the pre-trained YOLOv7 model for that task, which can be found under the <code>/releases/download/</code> tab on GitHub:
<pre><code class="hljs">! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt -o yolov7-w6-pose.pt

 % Total % Received % Xferd Average Speed Time Time Time Current
 Dload Upload Total Spent Left Speed
 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0
100 153M 100 153M 0 0 3742k 0 0:00:42 0:00:42 --:--:-- 4573k
</code></pre>
Great, we've downloaded the <code>yolov7-w6-pose.pt</code> weights file, which can be used to load and reconstruct a trained model for pose estimation.
<h2 id="loadingtheyolov7poseestimationmodel">Loading the YOLOv7 Pose Estimation Model</h2>
Let's import the libraries we'll need to perform pose estimation:
<pre><code class="hljs">import torch
from torchvision import transforms

from utils.datasets import letterbox
from utils.general import non_max_suppression_kpt
from utils.plots import output_to_keypoint, plot_skeleton_kpts

import matplotlib.pyplot as plt
import cv2
import numpy as np
</code></pre>
<code>torch</code> and <code>torchvision</code> are straightforward enough - YOLOv7 is implemented with PyTorch. The <code>utils.datasets</code>, <code>utils.general</code> and <code>utils.plots</code> modules come from the YOLOv7 project, and provide us with methods that help with preprocessing and preparing input for the model to run inference on. Amongst those are <code>letterbox()</code> to pad the image, <code>non_max_supression_keypoint()</code> to run the Non-Max Suppression algorithm on the initial output of the model and to produce a clean output for our interpretation, as well as the <code>output_to_keypoint()</code> and <code>plot_skeleton_kpts()</code> methods to actually add keypoints to a given image, once they're predicted.
We can load the model from the weight file with <code>torch.load()</code>. Let's create a function to check if a GPU is available, load the model, put it in inference mode and move it to the GPU if available:
<pre><code class="hljs">def load_model():
 device = torch.device(&quot;cuda:0&quot; if torch.cuda.is_available() else &quot;cpu&quot;)
 model = torch.load(&#x27;yolov7/yolov7-w6-pose.pt&#x27;, map_location=device)[&#x27;model&#x27;]
 # Put in inference mode
 model.float().eval()

 if torch.cuda.is_available():
 # half() turns predictions into float16 tensors
 # which significantly lowers inference time
 model.half().to(device)
 return model

model = load_model()
</code></pre>
With the model loaded, let's create a <code>run_inference()</code> method that accepts a string pointing to a file on our system. The method will read the image using OpenCV (<code>cv2</code>), pad it with <code>letterbox()</code>, apply transforms to it, and turn it into a batch (the model is trained on and expects batches, as usual):
<pre><code class="hljs">def run_inference(url):
 image = cv2.imread(url) # shape: (480, 640, 3)
 # Resize and pad image
 image = letterbox(image, 960, stride=64, auto=True)[0] # shape: (768, 960, 3)
 # Apply transforms
 image = transforms.ToTensor()(image) # torch.Size([3, 768, 960])
 # Turn image into batch
 image = image.unsqueeze(0) # torch.Size([1, 3, 768, 960])
 output, _ = model(image) # torch.Size([1, 45900, 57])
 return output, image
</code></pre>
Here, we've returned the transformed image (because we'll want to extract the original and plot on it) and the outputs of the model. These outputs contain 45900 keypoint predictions, most of which overlap. We'll want to apply Non-Max Suppression to these raw predictions, just as with Object Detection predictions (where many bounding boxes are predicted and then they're &quot;collapsed&quot; given some confidence and IoU threshold). After suppression, we can plot each keypoint on the original image and display it:
<pre><code class="hljs">def visualize_output(output, image):
 output = non_max_suppression_kpt(output, 
 0.25, # Confidence Threshold
 0.65, # IoU Threshold
 nc=model.yaml[&#x27;nc&#x27;], # Number of Classes
 nkpt=model.yaml[&#x27;nkpt&#x27;], # Number of Keypoints
 kpt_label=True)
 with torch.no_grad():
 output = output_to_keypoint(output)
 nimg = image[0].permute(1, 2, 0) * 255
 nimg = nimg.cpu().numpy().astype(np.uint8)
 nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
 for idx in range(output.shape[0]):
 plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)
 plt.figure(figsize=(12, 12))
 plt.axis(&#x27;off&#x27;)
 plt.imshow(nimg)
 plt.show()
</code></pre>
Now, for some input image, such as <code>karate.jpg</code> in the main working directory, we can run inference, perform Non-Max Suppression and plot the results with:
<pre><code class="hljs">output, image = run_inference(&#x27;../basketball.jpg&#x27;) # Bryan Reyes on Unsplash
visualize_output(output, image)
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/pose-estimationkeypoint-detection-with-yolov7-in-python-2.png" alt="">
Or another one:
<pre><code class="hljs">output, image = run_inference(&#x27;../karate.jpg&#x27;) # Mondo Generator on Unsplash
visualize_output(output, image)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/pose-estimationkeypoint-detection-with-yolov7-in-python-1.png" alt="">
This is a fairly difficult image to infer! Most of the right arm of the practitioner on the right is hidden, and we can see that the model inferred that it is hidden and to the right of the body, missing that the elbow is bent and that a portion of the arm is in front. The practitioner on the left, which is much more clearly seen, is inferred correctly, even with a hidden leg.
As a matter of fact - a person sitting in the back, almost fully invisible to the camera has had their pose seemingly correctly estimated, just based on the position of the hips while sitting down. Great work on behalf of the network!
<h2 id="conclusion">Conclusion</h2>
In this guide - we've taken a brief look at YOLOv7, the latest advancement in the YOLO family, which builds on top of YOLOR, and further provides instance segmentation and keypoint detection capabilities beyond the standard object detection capabilities of most YOLO-based models.
We've then taken a look at how we can download released weight files, load them in to construct a model and perform pose estimation inference for humans, yielding impressive results.

In this guide, learn how to perform near real-time pose estimation inference (keypoint detection) on images with a pre-trained model, using YOLOv7, implemented with Python and PyTorch.

Pose Estimation/Keypoint Detection with YOLOv7 in Python

<h2 id="introduction">Introduction</h2>
Object detection is a large field in computer vision, and one of the more important applications of computer vision &quot;in the wild&quot;.
Object detection isn't as standardized as image classification, mainly because most of the new developments are typically done by individual researchers, maintainers and developers, rather than large libraries and frameworks. It's difficult to package the necessary utility scripts in a framework like TensorFlow or PyTorch and maintain the API guidelines that guided the development so far.
This makes object detection somewhat more complex, typically more verbose (but not always), and less approachable than image classification.
Fortunately for the masses - Ultralytics has developed a simple, very powerful and beautiful object detection API around their YOLOv5 which has been extended by other research and development teams into newer versions, such as YOLOv7.
<blockquote>
In this short guide, we'll be performing Object Detection in Python, with state-of-the-art YOLOv7.
</blockquote>
<img src="https://s3.stackabuse.com/media/articles/real-time-object-detection-inference-in-python-with-yolov7-1.gif" alt="">
<h2 id="yololandscapeandyolov7">YOLO Landscape and YOLOv7</h2>
YOLO (You Only Look Once) is a methodology, as well as family of models built for object detection. Since the inception in 2015, YOLOv1, YOLOv2 (YOLO9000) and YOLOv3 have been proposed by the same author(s) - and the deep learning community continued with open-sourced advancements in the continuing years.
<a target="_blank" rel="nofollow noopener noreferrer" href="https://github.com/ultralytics/yolov5">Ultralytics' YOLOv5</a> is the first large-scale implementation of YOLO in PyTorch, which made it more accessible than ever before, but the main reason YOLOv5 has gained such a foothold is also the beautifully simple and powerful API built around it. The project abstracts away the unnecessary details, while allowing customizability, practically all usable export formats, and employs amazing practices that make the entire project both efficient and as optimal as it can be.
YOLOv5 is still the staple project to build Object Detection models with, and many repositories that aim to advance the YOLO method start with YOLOv5 as a baseline and offer a similar API (or simply fork the project and build on top of it). Such is the case of <a rel="nofollow noopener noreferrer" target="_blank" href="https://arxiv.org/abs/2105.04206">YOLOR (You Only Learn One Representation)</a> and YOLOv7 which built on top of YOLOR (same author). YOLOv7 is the latest advancement in the YOLO methodology and most notably, YOLOv7 provides new model heads that can output keypoints (skeletons) and perform instance segmentation besides only bounding box regression, which wasn't standard with previous YOLO models.
<blockquote>
This makes instance segmentation and keypoint detection faster than ever before!
</blockquote>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 It was released alongside a paper named <a rel="nofollow noopener noreferrer" target="_blank" href="https://arxiv.org/abs/2207.02696">&quot;YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors&quot;</a>, and the source code is available <a rel="nofollow noopener noreferrer" target="_blank" href="https://github.com/WongKinYiu/yolov7">on GitHub</a>.

 </div>
 </div>
 </div>
 In addition, YOLOv7 performs faster and to a higher degree of accuracy than previous models due to a reduced parameter count and higher computational efficiency:
<img src="https://s3.stackabuse.com/media/articles/real-time-object-detection-inference-in-python-with-yolov7-2.png" alt="">
The model itself was created through architectural changes, as well as optimizing aspects of training, dubbed &quot;bag-of-freebies&quot;, which increased accuracy without increasing inference cost.
<h2 id="installingyolov7">Installing YOLOv7</h2>
Installing and using YOLOv7 boils down to downloading the GitHub repository to your local machine and running the scripts that come packaged with it.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Unfortunately, as of writing, YOLOv7 doesn't offer a clean programmatic API such as YOLOv5, that's typically loaded from <code>torch.hub()</code>, passing the GitHub repository in. This appears to be a feature that should work but is currently failing. As it gets fixed, I'll update the guide or publish a new one on the programmatic API. For now - we'll focus on the inference scripts provided in the repository.

 </div>
 </div>
 </div>
 Even so, you can perform detection in real-time on videos, images, etc. and save the results easily. The project follows the same conventions as YOLOv5, which has an extensive documentation, so you're likely to find answers to more niche questions in the YOLOv5 repository if you have some.
Let's download the repository and perform some inference:
<pre><code class="hljs">! git clone https://github.com/WongKinYiu/yolov7.git
</code></pre>
This creates a <code>yolov7</code> directory in your current working directory, which houses the project. Let's move into that directory and take a look at the files:
<pre><code class="hljs">%cd yolov7
!ls
/Users/macbookpro/jup/yolov7
LICENSE.md detect.py models tools
README.md export.py paper train.py
cfg figure requirements.txt train_aux.py
data hubconf.py scripts utils
deploy inference test.py runs
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: On a Google Colab Notebook, you'll have to run the magic <code>%cd</code> command in each cell you wish to change your directory to <code>yolov7</code>, while the next cell returns you back to your original working directory. On Local Jupyter Notebooks, changing the directory once keeps you in it, so there's no need to re-issue the command multiple times.

 </div>
 </div>
 </div>
 The <code>detect.py</code> is the inference script that runs detections and saves the results under <code>runs/detect/video_name</code>, where you can specify the <code>video_name</code> while calling the <code>detect.py</code> script. <code>export.py</code> exports the model to various formats, such as ONNX, TFLite, etc. <code>train.py</code> can be used to train a custom YOLOv7 detector (the topic of another guide), and <code>test.py</code> can be used to test a detector (loaded from a weights file).
Several additional directories hold the configurations (<code>cfg</code>), example data (<code>inference</code>), data on constructing models and COCO configurations (<code>data</code>), etc.
<h2 id="yolov7sizes">YOLOv7 Sizes</h2>
YOLO-based models scale well, and are typically exported as smaller, less-accurate models, and larger, more-accurate models. These are then deployed to weaker or stronger devices respectively.
YOLOv7 offers several sizes, and benchmarked them against MS COCO:
<table class="table table-striped">
<thead>
 <tr>
 <th class="tg-lgpt">Model</th>
 <th class="tg-lgpt">Test Size</th>
 <th class="tg-lgpt">APtest</th>
 <th class="tg-xao6">AP50test</th>
 <th class="tg-xao6">AP75test</th>
 <th class="tg-xao6">batch 1 fps</th>
 <th class="tg-xao6">batch 32 average time</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td class="tg-nstd"><a href="https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt">YOLOv7</a></td>
 <td class="tg-m2ts">640</td>
 <td class="tg-nstd">51.4%</td>
 <td class="tg-l1d2">69.7%</td>
 <td class="tg-l1d2">55.9%</td>
 <td class="tg-cwad">161 fps</td>
 <td class="tg-cwad">2.8 ms</td>
 </tr>
 <tr>
 <td class="tg-nstd"><a href="https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7x.pt">YOLOv7-X</a></td>
 <td class="tg-m2ts">640</td>
 <td class="tg-nstd">53.1%</td>
 <td class="tg-l1d2">71.2%</td>
 <td class="tg-l1d2">57.8%</td>
 <td class="tg-cwad">114 fps</td>
 <td class="tg-cwad">4.3 ms</td>
 </tr>
 <tr>
 <td class="tg-m2ts"></td>
 <td class="tg-m2ts"></td>
 <td class="tg-m2ts"></td>
 <td class="tg-cwad"></td>
 <td class="tg-cwad"></td>
 <td class="tg-cwad"></td>
 <td class="tg-cwad"></td>
 </tr>
 <tr>
 <td class="tg-nstd"><a href="https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6.pt">YOLOv7-W6</a></td>
 <td class="tg-m2ts">1280</td>
 <td class="tg-nstd">54.9%</td>
 <td class="tg-l1d2">72.6%</td>
 <td class="tg-l1d2">60.1%</td>
 <td class="tg-cwad">84 fps</td>
 <td class="tg-cwad">7.6 ms</td>
 </tr>
 <tr>
 <td class="tg-nstd"><a href="https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6.pt">YOLOv7-E6</a></td>
 <td class="tg-m2ts">1280</td>
 <td class="tg-nstd">56.0%</td>
 <td class="tg-l1d2">73.5%</td>
 <td class="tg-l1d2">61.2%</td>
 <td class="tg-cwad">56 fps</td>
 <td class="tg-cwad">12.3 ms</td>
 </tr>
 <tr>
 <td class="tg-nstd"><a href="https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-d6.pt">YOLOv7-D6</a></td>
 <td class="tg-m2ts">1280</td>
 <td class="tg-nstd">56.6%</td>
 <td class="tg-l1d2">74.0%</td>
 <td class="tg-l1d2">61.8%</td>
 <td class="tg-cwad">44 fps</td>
 <td class="tg-cwad">15.0 ms</td>
 </tr>
 <tr>
 <td class="tg-nstd"><a href="https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-e6e.pt">YOLOv7-E6E</a></td>
 <td class="tg-m2ts">1280</td>
 <td class="tg-nstd">56.8%</td>
 <td class="tg-l1d2">74.4%</td>
 <td class="tg-l1d2">62.1%</td>
 <td class="tg-cwad">36 fps</td>
 <td class="tg-cwad">18.7 ms</td>
 </tr>
</tbody>
</table>
Depending on the underlying hardware you're expecting the model to run on, and the required accuracy - you can choose between them. The smallest model hits over 160 FPS on images of size 640, on a V100! You can expect satisfactory real-time performance on more common consumer GPUs as well.
<h2 id="videoinferencewithyolov7">Video Inference with YOLOv7</h2>
Create an <code>inference-data</code> folder to store the images and/or videos you'd like to detect from. Assuming it's in the same directory, we can run a detection script with:
<pre><code class="hljs">! python3 detect.py --source inference-data/busy_street.mp4 --weights yolov7.pt --name video_1 --view-img
</code></pre>
This will prompt a Qt-based video on your desktop in which you can see the live progress and inference, frame by frame, as well as output the status to our standard output pipe:
<pre><code class="hljs">Namespace(weights=[&#x27;yolov7.pt&#x27;], source=&#x27;inference-data/busy_street.mp4&#x27;, img_size=640, conf_thres=0.25, iou_thres=0.45, device=&#x27;&#x27;, view_img=True, save_txt=False, save_conf=False, nosave=False, classes=None, agnostic_nms=False, augment=False, update=False, project=&#x27;runs/detect&#x27;, name=&#x27;video_1&#x27;, exist_ok=False, no_trace=False)
YOLOR 🚀 v0.1-112-g55b90e1 torch 1.12.1 CPU

Downloading https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt to yolov7.pt...
100%|██████████████████████████████████████| 72.1M/72.1M [00:18&lt;00:00, 4.02MB/s]

Fusing layers... 
RepConv.fuse_repvgg_block
RepConv.fuse_repvgg_block
RepConv.fuse_repvgg_block
Model Summary: 306 layers, 36905341 parameters, 6652669 gradients
 Convert model to Traced-model... 
 traced_script_module saved! 
 model is traced! 
 
video 1/1 (1/402) /Users/macbookpro/jup/yolov7/inference-data/busy_street.mp4: 24 persons, 1 bicycle, 8 cars, 3 traffic lights, 2 backpacks, 2 handbags, Done. (1071.6ms) Inference, (2.4ms) NMS
video 1/1 (2/402) /Users/macbookpro/jup/yolov7/inference-data/busy_street.mp4: 24 persons, 1 bicycle, 8 cars, 3 traffic lights, 2 backpacks, 2 handbags, Done. (1070.8ms) Inference, (1.3ms) NMS
</code></pre>
Note that the project will run slow on CPU-based machines (such as 1000ms per inference step in the output above, ran on an Intel-based 2017 MacBook Pro), and significantly faster on GPU-based machines (closer to ~5ms/frame on a V100). Even on CPU-based systems such as this one, <code>yolov7-tiny.pt</code> runs at <code>172ms/frame</code>, which while far from real-time, is still very decent for handling these operations on a CPU.
Once the run is done, you can find the resulting video under <code>runs/video_1</code> (the name we supplied in the <code>detect.py</code> call), saved as an <code>.mp4</code>:
<img src="https://s3.stackabuse.com/media/articles/real-time-object-detection-inference-in-python-with-yolov7-1.gif" alt="">
<h2 id="inferenceonimages">Inference on Images</h2>
Inference on images boils down to the same process - supplying the URL to an image in the file system, and calling <code>detect.py</code>:
<pre><code class="hljs">! python3 detect.py --source inference-data/desk.jpg --weights yolov7.pt
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: As of writing, the output doesn't scale the labels to the image size, even if you set <code>--img SIZE</code>. This means that large images will have really thin bounding box lines and small labels.

 </div>
 </div>
 </div>
 <img src="https://s3.stackabuse.com/media/articles/real-time-object-detection-inference-in-python-with-yolov7-3.jpg" alt="">
<h2 id="conclusion">Conclusion</h2>
In this short guide - we've taken a brief look at YOLOv7, the latest advancement in the YOLO family, which builds on top of YOLOR. We've taken a look at how to install the repository on your local machine and run object detection inference scripts with a pre-trained network on videos and images.
In further guides, we'll be covering keypoint detection and instance segmentation.

In this guide, learn how to perform real-time object detection inference on images and videos with a pre-trained model, using YOLOv7, implemented with Python and PyTorch.

Real-Time Object Detection Inference in Python with YOLOv7

<h2 id="introduction">Introduction</h2>
In this article we'll show you how to force update a component in React.js. More specifically, we'll be giving a brief introduction to React re-renders, we'll show how to force updates in class-based components, and how to force updates in functional components.
<h2 id="reactrerenders">React Re-Renders</h2>
React itself automatically handles re-rendering components for you, in most cases. The cause of this can be based on when props or state has been updated. So when a state or property changes, the component re-renders. But what if your component is dependent on something else and not necessarily on your state or property? In that case you may need to force update the component since React may not have detected the change.
Let's take a look at how to use this forced update on a React component. To show this, we're going to create a simple application for demo purposes.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: We will be covering a few concepts of React, so having basic knowledge of React is advisable.

 </div>
 </div>
 </div>
 <h2 id="forcingupdatesonclassbasedcomponents">Forcing Updates on Class-Based Components</h2>
The class component has a built-in method for re-rendering a component, called <code>forceUpdate()</code>, which is used to force a component to re-render. You can read more about the <code>forceUpdate()</code> method on React's <a rel="nofollow noopener" target="_blank" href="https://reactjs.org/docs/react-component.html#forceupdate">official website</a>.
<pre><code class="hljs">handleForceupdateMethod() {
 // Force a render without state change...
 this.forceUpdate();
}
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: It is not advisable to rely on updating components using the <code>forceUpdate()</code> method. When you find yourself needing this method, you should first try to analyze your code and figure out if there is another reason why React is not updating the component. You may find that a bug is causing this or that you can restructure your code in a way that allows React to properly re-render the component on its own.

 </div>
 </div>
 </div>
 Here is an example of how to force an update on a class-based component:
<pre><code class="hljs">import React from &#x27;react&#x27;

class App extends React.Component {
 constructor() {
 super();
 this.handleForceupdateMethod = this.handleForceupdateMethod.bind(this);
 };

 handleForceupdateMethod() {
 this.forceUpdate();
 };

 render() {
 return (
 &lt;div&gt;
 &lt;h1&gt;Hello StackAbuse&lt;/h1&gt;
 &lt;h3&gt;Random Number: { Math.random() }&lt;/h3&gt;
 &lt;button onClick={this.handleForceupdateMethod}&gt;
 Force re-render
 &lt;/button&gt;
 &lt;/div&gt;
 );
 }
}

export default App
</code></pre>
There's a lot more going on within this method than it may seem. For example, calling <code>forceUpdate()</code> triggers the lifecycle methods for the child components as well. And as we know with React, it'll update the DOM only if the markup has actually changed.
You can access the <a rel="nofollow noopener" target="_blank" href="https://codesandbox.io/s/forcing-update-on-a-react-class-component-0v7hhw">live code here</a>.
<h2 id="forcingupdatesonfunctionalcomponents">Forcing Updates on Functional Components</h2>
Functional components have no built-in method for re-rendering components like their class-based counterparts do. This means that we don't have the <code>forceUpdate()</code> method available to us. However, recall that in React components typically re-render due to state or prop changes. Using this, we can achieve ways to force update.
As of v16.8+, React has a concept called Hooks which can be used in functional components for updating state, performing side-effects, etc. We'll use these hooks to our advantage in getting a component to re-render.

Here are some examples of how to force an update in a functional component:
Using the <code>useReducer</code> hook
<pre><code class="hljs">const [ignored, forceUpdate] = useReducer(x =&gt; x + 1, 0);

function handleClick() {
 forceUpdate();
}
</code></pre>
A reducer in React is typically used when you have complex state logic and actions. Here we use it simply to trigger the update by updating a dummy state variable, <code>x</code>. The state must actually change in order to trigger the update, which is why it's incremented on each call.
Use the <code>useState</code> hook
<pre><code class="hljs">import React, { useState } from &quot;react&quot;;

// Create your forceUpdate hook
function useForceUpdate() {
 let [value, setState] = useState(true);
 return () =&gt; setState(!value);
}

export default function App() {
 // Call your hook here
 const handleForceupdateMethod = useForceUpdate();

 return (
 &lt;div className=&quot;App&quot;&gt;
 &lt;h1&gt;Hello StackAbuse &lt;/h1&gt;
 &lt;h3&gt;Random Number: { Math.random() }&lt;/h3&gt;

 {/*
 Clicking on the button will force to re-render like force update does
 */}
 &lt;button onClick={handleForceupdateMethod}&gt;Force re-render&lt;/button&gt;
 &lt;/div&gt;
 );
}
</code></pre>
The idea behind this type of force update is very similar to <code>useReducer</code> in that we are constantly updating state to force the change. Instead of incrementing a counter, like we did in the last method, here we simply toggle a boolean value so that it is negated on each call.
Using the <code>useState</code> and <code>useCallback</code> hooks
<pre><code class="hljs">import React, { useState , useCallback} from &quot;react&quot;;

export default function App() {
 const [, updateState] = useState();
 const handleForceupdateMethod = useCallback(() =&gt; updateState({}), []);

 // Check your console
 console.log(&quot;Rendering...&quot;);

 return (
 &lt;div className=&quot;App&quot;&gt;
 &lt;h1&gt;Hello StackAbuse&lt;/h1&gt;
 &lt;h3&gt;Random Number: { Math.random() }&lt;/h3&gt;

 {/*
 Clicking on the button will force to re-render like force update does
 */}
 &lt;button onClick={handleForceupdateMethod}&gt;Force re-render&lt;/button&gt;
 &lt;/div&gt;
 );
}
</code></pre>
Again, this strategy works by changing the state. In this case, although we're not technically changing the value of the state, we are sending it a new object, which is considered new by React since it doesn't do &quot;deep&quot; equality checks on state.
As you can see, there are a number of ways to achieve the same thing here. Keep in mind that these are all technically anti-patterns and should be avoided when possible. But if you're not able to resolve the underlying issue and need to force update a component, then any of the methods we've shown here should work.
<h2 id="conclusion">Conclusion</h2>
In this article we have seen how to force updates on React components. We also saw how this can be achieved in both functional and class-based components. While not necessarily good practice, it is useful to understand how it works in case we need to use it in special cases.

Scott Robinson

Guest Contributor

How to Force Update a React Component

<h2 id="introduction">Introduction</h2>
Object detection is a large field in computer vision, and one of the more important applications of computer vision &quot;in the wild&quot;. On one end, it can be used to build autonomous systems that navigate agents through environments - be it robots performing tasks or self-driving cars, but this requires intersection with other fields. However, anomaly detection (such as defective products on a line), locating objects within images, facial detection and various other applications of object detection can be done without intersecting other fields.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice This short guide is based on a small part of a much larger lesson on object detection belonging to our <a target="_blank" href="https://stackabuse.com/courses/practical-deep-learning-for-computer-vision-with-python/">&quot;Practical Deep Learning for Computer Vision with Python&quot;</a> course.

 </div>
 </div>
 </div>
 Object detection isn't as standardized as image classification, mainly because most of the new developments are typically done by individual researchers, maintainers and developers, rather than large libraries and frameworks. It's difficult to package the necessary utility scripts in a framework like TensorFlow or PyTorch and maintain the API guidelines that guided the development so far.
This makes object detection somewhat more complex, typically more verbose (but not always), and less approachable than image classification. One of the major benefits of being in an ecosystem is that it provides you with a way to not search for useful information on good practices, tools and approaches to use. With object detection - most people have to do way more research on the landscape of the field to get a good grip.
Fortunately for the masses - Ultralytics has developed a simple, very powerful and beautiful object detection API around their YOLOv5 implementation.
<blockquote>
In this short guide, we'll be performing Object Detection in Python, with YOLOv5 built by Ultralytics in PyTorch, using a set of pre-trained weights trained on MS COCO.
</blockquote>
<h2 id="yolov5">YOLOv5</h2>
YOLO (You Only Look Once) is a methodology, as well as a family of models built for object detection. Since the inception in 2015, YOLOv1, YOLOv2 (YOLO9000) and YOLOv3 have been proposed by the same author(s) - and the deep learning community continued with open-sourced advancements in the continuing years.
<a target="_blank" rel="nofollow noopener noreferrer" href="https://github.com/ultralytics/yolov5">Ultralytics' YOLOv5</a> is the first large-scale implementation of YOLO in PyTorch, which made it more accessible than ever before, but the main reason YOLOv5 has gained such a foothold is also the beautifully simple and powerful API built around it. The project abstracts away the unnecessary details, while allowing customizability, practically all usable export formats, and employs amazing practices that make the entire project both efficient and as optimal as it can be. Truly, it's an example of the beauty of open source software implementation, and how it powers the world we live in.
The project provides pre-trained weights on MS COCO, a staple dataset on objects in context, which can be used to both benchmark and build general object detection systems - but most importantly, can be used to transfer general knowledge of objects in context to custom datasets.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you'd like to learn more about the YOLO method, as well as competitive methods such as SSDs (Single-Shot Detectors) and the two-stage detector camp including Faster R-CNN and retina net - our course lesson on <a target="_blank" href="https://stackabuse.com/courses/practical-deep-learning-for-computer-vision-with-python/lessons/object-detection/">&quot;Object Detection and Segmentation - R-CNNs, RetinaNet, SSD, YOLO&quot;</a>!

 </div>
 </div>
 </div>
 <h3 id="objectdetectionwithyolov5">Object Detection with YOLOv5</h3>
Before moving forward, make sure you have <code>torch</code> and <code>torchvision</code> installed:
<pre><code class="hljs">! python -m pip install torch torchvision
</code></pre>
YOLOv5's got detailed, no-nonsense documentation and a beautifully simple API, as shown on the repo itself, and in the following example:
<pre><code class="hljs">import torch
# Loading in yolov5s - you can switch to larger models such as yolov5m or yolov5l, or smaller such as yolov5n
model = torch.hub.load(&#x27;ultralytics/yolov5&#x27;, &#x27;yolov5s&#x27;)
img = &#x27;https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg&#x27; # or file, Path, PIL, OpenCV, numpy, list
results = model(img)
fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(results.render()[0])
plt.show()
</code></pre>
The second argument of the <code>hub.load()</code> method specifies the weights we'd like to use. By choosing anywhere between <code>yolov5n</code> to <code>yolov5l6</code> - we're loading in the MS COCO pre-trained weights. For custom models:
<pre><code class="hljs">model = torch.hub.load(&#x27;ultralytics/yolov5&#x27;, &#x27;custom&#x27;, path=&#x27;path_to_weights.pt&#x27;)
</code></pre>
In any case - once you pass the input through the model, the returned object includes helpful methods to interpret the results, and we've chosen to <code>render()</code> them, which returns a NumPy array that we can chuck into an <code>imshow()</code> call. This results in a nicely formatted:
<img src="https://s3.stackabuse.com/media/ebooks/deep+learning+computer+vision/lesson_9/object-detection-6.png" alt="">
<h2 id="savingresultsasfiles">Saving Results as Files</h2>
You can save the results of the inference as a file, using the <code>results.save()</code> method:
<pre><code class="hljs">results.save(save_dir=&#x27;results&#x27;)
</code></pre>
This will create a new directory if it isn't already present, and save the same image we've just plotted as a file.
<h2 id="croppingoutobjects">Cropping Out Objects</h2>
You can also decide to crop out the detected objects as individual files. In our case, for every label detected, a number of images can be extracted. This is easily achieved via the <code>results.crop()</code> method, which creates a <code>runs/detect/</code> directory, with <code>expN/crops</code> (where N increases for each run), in which a directory with cropped images is made for each label:
<pre><code class="hljs">results.crop()
</code></pre>
<pre><code class="hljs">Saved 1 image to runs/detect/exp2
Saved results to runs/detect/exp2

[{&#x27;box&#x27;: [tensor(295.09409),
 tensor(277.03699),
 tensor(514.16113),
 tensor(494.83691)],
 &#x27;conf&#x27;: tensor(0.25112),
 &#x27;cls&#x27;: tensor(0.),
 &#x27;label&#x27;: &#x27;person 0.25&#x27;,
 &#x27;im&#x27;: array([[[167, 186, 165],
 [174, 184, 167],
 [173, 184, 164],
</code></pre>
You can also verify the output file structure with:
<pre><code class="hljs">! ls runs/detect/exp2/crops
# crops maxresdefault.jpg

! ls runs/detect/exp2/crops
# backpack bus car handbag person &#x27;traffic light&#x27; umbrella
</code></pre>
<h2 id="objectcounting">Object Counting</h2>
By default, when you perform detection or print the <code>results</code> object - you'll get the number of images that inference was performed on for that <code>results</code> object (YOLOv5 works with batches of images as well), its resolution and the count of each label detected:
<pre><code class="hljs">print(results)
</code></pre>
This results in:
<pre><code class="hljs">image 1/1: 720x1280 14 persons, 1 car, 3 buss, 6 traffic lights, 1 backpack, 1 umbrella, 1 handbag
Speed: 35.0ms pre-process, 256.2ms inference, 0.7ms NMS per image at shape (1, 3, 384, 640)
</code></pre>
<h3 id="inferencewithscripts">Inference with Scripts</h3>
Alternatively, you can run the detection script, <code>detect.py</code>, by cloning the YOLOv5 repository:
<pre><code class="hljs">$ git clone https://github.com/ultralytics/yolov5 
$ cd yolov5
$ pip install -r requirements.txt
</code></pre>
And then running:
<pre><code class="hljs">$ python detect.py --source img.jpg
</code></pre>
Alternatively, you can provide a URL, video file, path to a directory with multiple files, a glob in a path to only match for certain files, a YouTube link or any other HTTP stream. The results are saved into the <code>runs/detect</code> directory.
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how you can perform object detection with YOLOv5 built using PyTorch.

In this short Python guide, learn how to perform object detection with a pre-trained MS COCO object detector - using YOLOv5 implemented in PyTorch.

Object Detection Inference in Python with YOLOv5 and PyTorch

Most practitioners, while first learning about Convolutional Neural Network (CNN) architectures - learn that it's comprised of three basic segments:
<ul>
<li>Convolutional Layers</li>
<li>Pooling Layers</li>
<li>Fully-Connected Layers</li>
</ul>
Most resources have some variation on this segmentation, including my own book. Especially online - fully-connected layers refer to a flattening layer and (usually) multiple dense layers.
This used to be the norm, and well-known architectures such as VGGNets used this approach, and would end in:
<pre><code class="hljs">model = keras.Sequential([
 #...
 keras.layers.MaxPooling2D((2, 2), strides=(2, 2), padding=&#x27;same&#x27;),
 keras.layers.Flatten(),
 keras.layers.Dropout(0.5),
 keras.layers.Dense(4096, activation=&#x27;relu&#x27;), 
 keras.layers.Dropout(0.5),
 keras.layers.Dense(4096, activation=&#x27;relu&#x27;),
 keras.layers.Dense(n_classes, activation=&#x27;softmax&#x27;)
])
</code></pre>
Though, for some reason - it's oftentimes forgotten that VGGNet was practically the last architecture to use this approach, due to the obvious computational bottleneck it creates. As soon as ResNets, published just the year after VGGNets (and 7 years ago), all mainstream architectures ended their model definitions with:
<pre><code class="hljs">model = keras.Sequential([
 #...
 keras.layers.GlobalAveragePooling2D(),
 keras.layers.Dense(n_classes, activation=&#x27;softmax&#x27;)
])
</code></pre>
Flattening in CNNs has been sticking around for 7 years. 7 years! And not enough people seem to be talking about the damaging effect it has on both your learning experience and the computational resources you're using.
<blockquote>
Global Average Pooling is preferable on many accounts over flattening. If you're prototyping a small CNN - use Global Pooling. If you're teaching someone about CNNs - use Global Pooling. If you're making an MVP - use Global Pooling. Use flattening layers for other use cases where they're actually needed.
</blockquote>
<h2 id="casestudyflatteningvsglobalpooling">Case Study - Flattening vs Global Pooling</h2>
Global Pooling condenses all of the feature maps into a single one, pooling all of the relevant information into a single map that can be easily understood by a single dense classification layer instead of multiple layers. It's typically applied as average pooling (<code>GlobalAveragePooling2D</code>) or max pooling (<code>GlobalMaxPooling2D</code>) and can work for 1D and 3D input as well.
Instead of flattening a feature map such as <code>(7, 7, 32)</code> into a vector of length 1536 and training one or multiple layers to discern patterns from this long vector: we can condense it into a <code>(7, 7)</code> vector and classify directly from there. It's that simple!
Note that bottleneck layers for networks like ResNets count in tens of thousands of features, not a mere 1536. When flattening, you're torturing your network to learn from oddly-shaped vectors in a very inefficient manner. Imagine a 2D image being sliced on every pixel row and then concatenated into a flat vector. The two pixels that used to be 0 pixels apart vertically are not <code>feature_map_width</code> pixels away horizontally! While this may not matter too much for a classification algorithm, which favors spatial invariance - this wouldn't be even conceptually good for other applications of computer vision.
Let's define a small demonstrative network that uses a flattening layer with a couple of dense layers:
<pre><code class="hljs">model = keras.Sequential([
 keras.layers.Input(shape=(224, 224, 3)),
 keras.layers.Conv2D(32, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.Conv2D(32, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.MaxPooling2D((2, 2), (2, 2)),
 keras.layers.BatchNormalization(),
 keras.layers.Conv2D(64, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.Conv2D(64, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.MaxPooling2D((2, 2), (2, 2)),
 keras.layers.BatchNormalization(),
 keras.layers.Flatten(),
 keras.layers.Dropout(0.3),
 keras.layers.Dense(64, activation=&#x27;relu&#x27;),
 keras.layers.Dense(32, activation=&#x27;relu&#x27;),
 keras.layers.Dense(10, activation=&#x27;softmax&#x27;)
])
model.summary()
</code></pre>
What does the summary look like?
<pre><code class="hljs">... 
 dense_6 (Dense) (None, 10) 330 
 
=================================================================
Total params: 11,574,090
Trainable params: 11,573,898
Non-trainable params: 192
_________________________________________________________________
</code></pre>
11.5M parameters for a toy network - and watch the parameters explode with larger input. 11.5M parameters. EfficientNets, one of the best performing networks ever designed, works at ~6M parameters, and can't be compared with this simple model in terms of actual performance and capacity to learn from data.
We could reduce this number significantly by making the network deeper, which would introduce more max pooling (and potentially strided convolution) to reduce the feature maps before they're flattened. However, consider that we'd be making the network more complex in order to make it less computationally expensive, all for the sake of a single layer that's throwing a wrench in the plans.
<blockquote>
Going deeper with layers should be to extract more meaningful, non-linear relationships between data points, not reducing the input size to cater to a flattening layer.
</blockquote>
Here's a network with global pooling:
<pre><code class="hljs">model = keras.Sequential([
 keras.layers.Input(shape=(224, 224, 3)),
 keras.layers.Conv2D(32, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.Conv2D(32, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.MaxPooling2D((2, 2), (2, 2)),
 keras.layers.BatchNormalization(),
 keras.layers.Conv2D(64, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.Conv2D(64, (3, 3), activation=&#x27;relu&#x27;),
 keras.layers.MaxPooling2D((2, 2), (2, 2)),
 keras.layers.BatchNormalization(),
 keras.layers.GlobalAveragePooling2D(),
 keras.layers.Dropout(0.3),
 keras.layers.Dense(10, activation=&#x27;softmax&#x27;)
])

model.summary()
</code></pre>
Summary?
<pre><code class="hljs"> dense_8 (Dense) (None, 10) 650 
 
=================================================================
Total params: 66,602
Trainable params: 66,410
Non-trainable params: 192
_________________________________________________________________
</code></pre>
Much better! If we go deeper with this model, the parameter count will increase, and we might be able to capture more intricate patterns of data with the new layers. If done naively though, the same issues that bound VGGNets will arise.
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at an alternative to flattening in CNN architecture design. Albeit short - the guide addresses a common issue when designing prototypes or MVPs, and advises you to use a better alternative to flattening.
Any seasoned Computer Vision Engineer will know and apply this principle, and the practice is taken for granted. Unfortunately, it doesn't seem to be properly relayed to new practitioners who are just entering the field, and can create sticky habits that take a while to get rid of.
If you're getting into Computer Vision - do yourself a favor and don't use flattening layers before classification heads in your learning journey.

Flatten() vs GlobalAveragePooling()? In this guide, you'll learn why you shouldn't use flattening for CNN development, and why you should prefer global pooling (average or max), with practical examples in Python, TensorFlow and Keras.

Don't Use Flatten() - Global Pooling for CNNs with TensorFlow and Keras

Deep Learning frameworks like Keras lower the barrier to entry for the masses and democratize the development of DL models to unexperienced folk, who can rely on reasonable defaults and simplified APIs to bear the brunt of heavy lifting, and produce decent results.
A common confusion arises between newer deep learning practitioners when using Keras loss functions for classification, such as <code>CategoricalCrossentropy</code> and <code>SparseCategoricalCrossentropy</code>:
<pre><code class="hljs">loss = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# Or
loss = keras.losses.SparseCategoricalCrossentropy(from_logits=False)
</code></pre>
<blockquote>
What does the <code>from_logits</code> flag refer to?
</blockquote>
The answer is fairly simple, but requires a look at the output of the network we're trying to grade using the loss function.
<h2 id="logitsandsoftmaxprobabilities">Logits and SoftMax Probabilities</h2>
Long story short:
<blockquote>
Probabilities are normalized - i.e. have a range between <code>[0..1]</code>. Logits aren't normalized, and can have a range between <code>[-inf...+inf]</code>.
</blockquote>
Depending on the output layer of your network:
<pre><code class="hljs">output = keras.layers.Dense(n, activation=&#x27;softmax&#x27;)(x)
# Or
output = keras.layers.Dense(n)(x)
</code></pre>
The output of the <code>Dense</code> layer will either return:
<ul>
<li>probabilities: The output is passed through a SoftMax function which normalizes the output into a set of probabilities over <code>n</code>, that all add up to <code>1</code>.</li>
<li>logits: <code>n</code> activations.</li>
</ul>
This misconception possibly arises from the short-hand syntax that allows you to add an activation to a layer, seemingly as a single layer, even though it's just shorthand for:
<pre><code class="hljs">output = keras.layers.Dense(n, activation=&#x27;softmax&#x27;)(x)
# Equivalent to
dense = keras.layers.Dense(n)(x)
output = keras.layers.Activation(&#x27;softmax&#x27;)(dense)
</code></pre>
Your loss function has to be informed as to whether it should expect a normalized distribution (output passed through a SoftMax function) or logits. Hence, the <code>from_logits</code> flag!
<h2 id="whenshouldfrom_logitstrue">When Should from_logits=True?</h2>
<blockquote>
If your output layer has a <code>'softmax'</code> activation, <code>from_logits</code> should be <code>False</code>. If your output layer doesn't have a <code>'softmax'</code> activation, <code>from_logits</code> should be <code>True</code>.
</blockquote>
If your network normalizes the output probabilities, your loss function should set <code>from_logits</code> to <code>False</code>, as it's not accepting logits. This is also the default value of all loss classes that accept the flag, as most people add an <code>activation='softmax'</code> to their output layers:
<pre><code class="hljs">model = keras.Sequential([
 keras.layers.Input(shape=(10, 1)),
 # Outputs normalized probability - from_logits=False
 keras.layers.Dense(10, activation=&#x27;softmax&#x27;) 
])

input_data = tf.random.uniform(shape=[1, 1])
output = model(input_data)
print(output)
</code></pre>
This results in:
<pre><code class="hljs">tf.Tensor(
[[[0.12467965 0.10423233 0.10054766 0.09162105 0.09144577 0.07093797
 0.12523937 0.11292477 0.06583504 0.11253635]]], shape=(1, 1, 10), dtype=float32)
</code></pre>
Since this network results in a normalized distribution - when comparing the outputs with target outputs, and grading them via a classification loss function (for the appropriate task) - you should set <code>from_logits</code> to <code>False</code>, or let the default value stay.
On the other hand, if your network doesn't apply SoftMax on the output:
<pre><code class="hljs">model = keras.Sequential([
 keras.layers.Input(shape=(10, 1)),
 # Outputs logits - from_logits=True
 keras.layers.Dense(10)
])

input_data = tf.random.uniform(shape=[1, 1])
output = model(input_data)
print(output)
</code></pre>
This results in:
<pre><code class="hljs">tf.Tensor(
[[[-0.06081138 0.04154852 0.00153442 0.0705068 -0.01139916
 0.08506121 0.1211026 -0.10112958 -0.03410497 0.08653068]]], shape=(1, 1, 10), dtype=float32)
</code></pre>
You'd need to set <code>from_logits</code> to <code>True</code> for the loss function to properly treat the outputs.
<h2 id="whentousesoftmaxontheoutput">When to Use SoftMax on the Output?</h2>
Most practitioners apply SoftMax on the output to give a normalized probability distribution, as this is in many cases what you'll use a network for - especially in simplified educational material. However, in some cases, you don't want to apply the function to the output, to process it in a different way before applying either SoftMax or another function.
A notable example comes from NLP models, in which a really the probability over a large vocabulary can be present in the output tensor. Applying SoftMax over all of them and greedily getting the <code>argmax</code> typically doesn't produce very good results.
However, if you observe the logits, extract the Top-K (where K can be any number but is typically somewhere between <code>[0...10]</code>), and only then applying SoftMax to the top-k possible tokens in the vocabulary shifts the distribution significantly, and usually produces more realistic results.
This is known as Top-K sampling, and while it isn't the ideal strategy, usually significantly outperforms greedy sampling.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: To see this principle in action in an end-to-end project that teaches you the crux of building autoregressive language models with TensorFlow and Keras - read our <a target="_blank" href="https://stackabuse.com/gpt-style-text-generation-in-python-with-tensorflowkeras/">&quot;5-Line GPT-Style Text Generation in Python with TensorFlow/Keras&quot;</a>!

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at the <code>from_logits</code> argument for Keras loss classes, which oftentimes raise questions with newer practitioners.
The confusion possibly arises from the short-hand syntax that allows the addition of activation layers on top of other layers, within the definition of a layer itself. We've finally taken a look at when the argument should be set to <code>True</code> or <code>False</code>, and when an output should be left as logits or passed through an activation function such as SoftMax.

In this short Python guide, learn what the from_logits argument means and does in Keras/TensorFlow loss functions, such as CategoricalCrossentropy and SparseCategoricalCrossentropy, as well as when you should set it to True or False.