{"id":2877,"date":"2022-06-16T21:42:02","date_gmt":"2022-06-17T01:42:02","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=2877"},"modified":"2022-06-16T21:42:02","modified_gmt":"2022-06-17T01:42:02","slug":"numpy-fix-invalid-value-encountered-in-true_divide","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/numpy-fix-invalid-value-encountered-in-true_divide-024221\/","title":{"rendered":"NumPy Fix: Invalid Value Encountered in true_divide"},"content":{"rendered":"

NumPy is a powerful scientific computing library for Python via which developers can make short work of matrix operations, random number generation, and many other complex mathematical functions. It rocks — but sometimes one runs into an error that isn’t readily understood.<\/p>\n

In this quick breakdown, we’ll look at such a case where NumPy might produce a runtime warning indicating that an invalid value was encountered while using the true_divide function<\/a>. As the error suggests, this error arises from — wait for it — using an invalid value during a division process. Most commonly, this happens when a 0 or NaN appears as the denominator.<\/p>\n

TL;DR<\/h2>\n

If you try to use the true_divide<\/code> function in NumPy when there are two 0<\/code>‘s present Python will generate a RuntimeWarning<\/code>. Consider the following:<\/p>\n

# Two np.array objects\r\nb_1 = np.array([5, 6, 7, 8, 0])\r\nb_2 = np.array([1, 2, 3, 4, 0])\r\n\r\n# Divided using true_divide\r\nprint(np.true_divide(b_1, b_2))\r\n\r\n# Doesn't crash the program\r\n[5.         3.         2.33333333 2.                nan]\r\n\r\n# But throws the following warning\r\nRuntimeWarning: divide by zero encountered in true_divide\r\n  print(np.true_divide(b_1, b_2))<\/pre>\n
The solution is to address the issue of the 0<\/code>‘s shown as the last element in both the b_1<\/code> and b_2<\/code> array — with the 0<\/code> in b_2<\/code> being prioritized as it would still cause a RuntimeWarning<\/code> for dividing by zero even if the 0<\/code> in b_1<\/code> were replaced.<\/p>\n
Quick Intro: The true_divide Function<\/h2>\n
NumPy’s true_divide<\/code> function is designed to make dividing collections of values such as arrays. It can be used to divide an array (a.k.a. matrix) via another array or by a single value. In either case, the operation happens element-wise.<\/p>\n
Note<\/strong>: The true_divide<\/code> function requires that two arrays be the same shape.<\/p>\n
Below is a quick example of the true_divide<\/code> method being used to divide an array into another:<\/p>\n
import numpy as np\r\n\r\n# Define some arrays\r\na_1 = [6, 7, 8, 9, 10]\r\na_2 = [1, 2, 3, 4, 5]\r\n\r\n# Use true_divide explicitly\r\nprint(np.true_divide(a_1, a_2))\r\n\r\n# Result\r\n[6. 3.5 2.66666667 2.25 2. ]\r\n\r\n# works with a single value as well\r\nprint(np.true_divide(a_1, 3))\r\n\r\n# Result\r\n[2. 2.33333333 2.66666667 3. 3.33333333]<\/pre>\n
NumPy\u00a0 also allows the implicit use of true_divide<\/code> via the \/<\/code> and \/\/<\/code> operators when used between two NumPy arrays:<\/p>\n
# Implicit use after converting to an array\r\nprint(np.array(a_1) \/ np.array(a_2))\r\n\r\n# Result\r\n[6.         3.5        2.66666667 2.25       2.        ]\r\n\r\n# Implicit use after converting to an array,\r\n# and using static value\r\nprint(np.array(a_1) \/ 3)\r\n\r\n# Result\r\n[2.         2.33333333 2.66666667 3.         3.33333333]\r\n\r\n# Use of floor division\r\nprint(np.array(a_1) \/\/ np.array(a_2))\r\n\r\n# Result\r\n[6 3 2 2 2]\r\n\r\n# Use of floor division with single value\r\n# Use of floor division\r\nprint(np.array(a_1) \/\/ 3)\r\n\r\n# Result\r\n[2 2 2 3 3]<\/pre>\n
However, should one try to use these types of syntaxes with non-np arrays one will receive an error:<\/p>\n
# Divide two lists\r\nprint(a_1 \/\/ a_2)\r\n\r\nTypeError: unsupported operand type(s) for \/\/: 'list' and 'list'<\/pre>\n
The closest pure-Python analog to the true_divide<\/code> function would be a custom list comprehension as such:<\/p>\n
# Elementwise division of two lists\r\nvals = [x \/ a_2[i] for i, x in enumerate(a_1)]\r\nprint(vals)\r\n\r\n# Result\r\n[6.0, 3.5, 2.6666666666666665, 2.25, 2.0]\r\n\r\n# Elementwise division of two lists, using floor division\r\nvals = [x \/\/ a_2[i] for i, x in enumerate(a_1)]\r\nprint(vals)\r\n\r\n# Result\r\n[6, 3, 2, 2, 2]<\/pre>\n
While convenient to stay in the syntax of Python — and avoid a dependency — this syntax becomes clunky and unclear<\/a> if used often. Now that we have an idea of how collections can be multiplied with or without NumPy, let’s consider some issues that may arise when using NumPy specifically.<\/p>\n
The Issue: Invalid Value Encountered in true_divide<\/h2>\n
The true_divide<\/code> function, much like most division functions, does not accommodate the division via 0<\/code>, NaN<\/code>, or otherwise zero-ish<\/em> values. Below we’ll create two NumPy arrays, each with a value of 0<\/code> included and attempt the true_divide<\/code> function.<\/p>\n
# Create 2 np.array objects\r\nb_1 = np.array([5, 6, 7, 8, 0])\r\nb_2 = np.array([1, 2, 3, 4, 0])\r\n\r\n# do an explicit true_divide\r\nprint(np.true_divide(b_1, b_2))\r\n\r\n# Result\r\n[5.         3.         2.33333333 2.                nan]\r\n\r\nRuntimeWarning: invalid value encountered in true_divide\r\n  print(np.true_divide(b_1, b_2))\r\n\r\n<\/pre>\n
First off it’s important to note this isn’t an Exception<\/code> but rather a Warning<\/code> — a RuntimeWarning<\/code> to be exact. This won’t’ cause a program to crash but will result in an NaN<\/code> value in the resulting array. The fix is to remove the zeroes.<\/p>\n
Another Issue: Divide by Zero Encountered in true_divide<\/h2>\n
Removing the 0<\/code> in the first array will sidestep the RuntimeWarning<\/code> issue regarding the invalid value but will present another RuntimeWarning<\/code> issue: dividing by zero<\/strong>. Consider the following code:<\/p>\n
#\u00a0Create\u00a02\u00a0np.array\u00a0objects\u00a0\r\nb_1 = np.array([5, 6, 7, 8, 1])\r\nb_2 = np.array([1, 2, 3, 4, 0])  \r\n\r\n#\u00a0do\u00a0an\u00a0explicit\u00a0true_divide\u00a0\r\nprint(np.true_divide(b_1, b_2))\r\n\r\n# Result\r\n[5.         3.         2.33333333 2.                inf]\r\n\r\nRuntimeWarning: divide by zero encountered in true_divide\r\n  print(np.true_divide(b_1, b_2))\r\n\r\n<\/pre>\n
Note here the return value consists of an np.array<\/code> object in which the last element is the value inf<\/code> representing infinity. This might be desired behavior depending on one’s application hence the issuance of a Warning<\/code> rather than an Exception<\/code>.<\/p>\n
Final Thoughts<\/h2>\n
NumPy is a powerful library and is an under-the-hood dependency of many of the most popular data science libraries like Pandas, Sci-kit Learn, and even Machine learning libraries like Tensor Flow<\/a>. It can supercharge matrix-based calculations and provides enough convenience functions to write\u00a0books<\/em> about.<\/p>\n
The odd behavior noted here comes from very contrived, intentional examples. In many cases, these errors may arise when a 0<\/code> or NaN<\/code> value is unknowingly present in an array. For example, perhaps such a value results after a first calculation such that the RuntimeWarning<\/code> is generated during the second — hard to check for that beforehand!<\/p>\n","protected":false},"excerpt":{"rendered":"
NumPy is a powerful scientific computing library for Python via which developers can make short work of matrix operations, random number generation, and many other complex mathematical functions. It rocks — but sometimes one runs into an error that isn’t readily understood. In this quick breakdown, we’ll look at such a case where NumPy might […]<\/p>\n","protected":false},"author":2,"featured_media":2878,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[186],"tags":[445,196,157,198,143,656],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2877"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=2877"}],"version-history":[{"count":1,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2877\/revisions"}],"predecessor-version":[{"id":2879,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/2877\/revisions\/2879"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/2878"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=2877"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=2877"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=2877"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}