TensorFlow

 by   paramsingh96 Python Version: Current License: Non-SPDX

kandi X-RAY | TensorFlow Summary

kandi X-RAY | TensorFlow Summary

TensorFlow is a Python library. TensorFlow has no bugs and it has low support. However TensorFlow has 20 vulnerabilities, it build file is not available and it has a Non-SPDX License. You can download it from GitHub.

TensorFlow
Support
    Quality
      Security
        License
          Reuse

            kandi-support Support

              TensorFlow has a low active ecosystem.
              It has 7 star(s) with 4 fork(s). There are 1 watchers for this library.
              OutlinedDot
              It had no major release in the last 6 months.
              TensorFlow has no issues reported. There are 2 open pull requests and 0 closed requests.
              It has a neutral sentiment in the developer community.
              The latest version of TensorFlow is current.

            kandi-Quality Quality

              TensorFlow has no bugs reported.

            kandi-Security Security

              TensorFlow has 20 vulnerability issues reported (4 critical, 7 high, 7 medium, 2 low).

            kandi-License License

              TensorFlow has a Non-SPDX License.
              Non-SPDX licenses can be open source with a non SPDX compliant license, or non open source licenses, and you need to review them closely before use.

            kandi-Reuse Reuse

              TensorFlow releases are not available. You will need to build from source code and install.
              TensorFlow has no build file. You will be need to create the build yourself to build the component from source.

            Top functions reviewed by kandi - BETA

            kandi has reviewed TensorFlow and discovered the below as its top functions. This is intended to give you an instant insight into TensorFlow implemented functionality, and help decide if they suit your requirements.
            • Run inference on an image
            • Create graph from saved graph_def
            • Return a string representation of a node
            • Download and extract the tarball
            • Compute the model
            Get all kandi verified functions for this library.

            TensorFlow Key Features

            No Key Features are available at this moment for TensorFlow.

            TensorFlow Examples and Code Snippets

            No Code Snippets are available at this moment for TensorFlow.

            Community Discussions

            QUESTION

            Model.evaluate returns 0 loss when using custom model
            Asked 2021-Jun-15 at 15:52

            I am trying to use my own train step in with Keras by creating a class that inherits from Model. It seems that the training works correctly but the evaluate function always returns 0 on the loss even if I send to it the train data, which have a big loss value during the training. I can't share my code but was able to reproduce using the example form the Keras api in https://keras.io/guides/customizing_what_happens_in_fit/ I changed the Dense layer to have 2 units instead of one, and made its activation to sigmoid.

            The code:

            ...

            ANSWER

            Answered 2021-Jun-12 at 17:27

            As you manually use the loss and metrics function in the train_step (not in the .compile) for the training set, you should also do the same for the validation set or by defining the test_step in the custom model in order to get the loss score and metrics score. Add the following function to your custom model.

            Source https://stackoverflow.com/questions/67951244

            QUESTION

            How to pass embedded data through a specific layers of TensorFlow model?
            Asked 2021-Jun-15 at 15:28

            Good day, everyone.

            I want to have two separate TensorFlow models (f and g) and train both of them on the loss of f(g(x)). However, I want to use them separately, like g(x) or f(e), where e is an embedded vector but received not from g.

            For example, the classical way to create the model with embedding looks like this:

            ...

            ANSWER

            Answered 2021-Jun-15 at 10:53

            This can be achieved by weight sharing or shared layers. To share layers in different models in keras, you just need to pass the same instance of layer to both of the models.

            Example Codes:

            Source https://stackoverflow.com/questions/67980314

            QUESTION

            How can I find to access to GPUs via Tensorflow in PyCharm?
            Asked 2021-Jun-15 at 14:43

            I have a problem about not accessing GPU in PyCharm and I use NVIDIA as GPU.

            I installed tensorflow-gpu in Python Interpreter of Setting part in Pycharm and then I run the code but I still cannot access it.

            I wonder if I should use CUDA library? How can I fix it?

            Here is my code snippet which is shown below.

            ...

            ANSWER

            Answered 2021-Jun-14 at 11:14

            I fixed my issue.

            Here are the steps of solving that issue.

            1 ) Download CUDA from https://developer.nvidia.com/cuda-downloads

            2 ) Download CUDNN from https://developer.nvidia.com/rdp/cudnn-download

            3 ) Copy bin,include and lastly lib from CUDNN zip file and paste it C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA{version}

            4 ) Then run the .py code in PyCharm and it perceives GPU at last.

            Source https://stackoverflow.com/questions/67952801

            QUESTION

            Recommended way of measuring execution time in Tensorflow Federated
            Asked 2021-Jun-15 at 13:49

            I would like to know whether there is a recommended way of measuring execution time in Tensorflow Federated. To be more specific, if one would like to extract the execution time for each client in a certain round, e.g., for each client involved in a FedAvg round, saving the time stamp before the local training starts and the time stamp just before sending back the updates, what is the best (or just correct) strategy to do this? Furthermore, since the clients' code run in parallel, are such a time stamps untruthful (especially considering the hypothesis that different clients may be using differently sized models for local training)?

            To be very practical, using tf.timestamp() at the beginning and at the end of @tf.function client_update(model, dataset, server_message, client_optimizer) -- this is probably a simplified signature -- and then subtracting such time stamps is appropriate?

            I have the feeling that this is not the right way to do this given that clients run in parallel on the same machine.

            Thanks to anyone can help me on that.

            ...

            ANSWER

            Answered 2021-Jun-15 at 12:01

            There are multiple potential places to measure execution time, first might be defining very specifically what is the intended measurement.

            1. Measuring the training time of each client as proposed is a great way to get a sense of the variability among clients. This could help identify whether rounds frequently have stragglers. Using tf.timestamp() at the beginning and end of the client_update function seems reasonable. The question correctly notes that this happens in parallel, summing all of these times would be akin to CPU time.

            2. Measuring the time it takes to complete all client training in a round would generally be the maximum of the values above. This might not be true when simulating FL in TFF, as TFF maybe decided to run some number of clients sequentially due to system resources constraints. In practice all of these clients would run in parallel.

            3. Measuring the time it takes to complete a full round (the maximum time it takes to run a client, plus the time it takes for the server to update) could be done by moving the tf.timestamp calls to the outer training loop. This would be wrapping the call to trainer.next() in the snippet on https://www.tensorflow.org/federated. This would be most similar to elapsed real time (wall clock time).

            Source https://stackoverflow.com/questions/67982276

            QUESTION

            Problem with FULLY_CONNECTED op in TF Lite
            Asked 2021-Jun-15 at 13:22

            I'd like to run a simple neural network model which uses Keras on a Rasperry microcontroller. I get a problem when I use a layer. The code is defined like this:

            ...

            ANSWER

            Answered 2021-May-25 at 01:08

            I had the same problem, man. I want to transplant tflite to the development board of CEVA. There is no problem in compiling. In the process of running, there is also an error in AddBuiltin(full_connect). At present, the only possible situation I guess is that some devices can not support tflite.

            Source https://stackoverflow.com/questions/67677228

            QUESTION

            Using TensorFlow with GPU taking a long time for loading library related to CUDA
            Asked 2021-Jun-15 at 13:04

            Machine Setting:

            • GPU: GeForce RTX 3060

            • Driver Version: 460.73.01

            • CUDA Driver Veresion: 11.2

            • Tensorflow: tensorflow-gpu 1.14.0

            • CUDA Runtime Version: 10.0

            • cudnn: 7.4.1

            Note:

            1. CUDA Runtime and cudnn version fits the guide from Tensorflow official documentation.
            2. I've also tried for TensorFlow-gpu = 2.0, still the same problem.

            Problem:

            I am using Tensorflow for an objection detection task. My situation is that the program will stuck at

            2021-06-05 12:16:54.099778: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcublas.so.10

            for several minutes.

            And then stuck at next loading process

            2021-06-05 12:21:22.212818: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library libcudnn.so.7

            for even longer time. You may check log.txt for log details.

            After waiting for around 30 mins, the program will start to running and WORK WELL.

            However, whenever program invoke self.session.run(...), it will load the same two library related to cuda (libcublas and libcudnn) again, which is time-wasted and annoying.

            I am confused that where the problem comes from and how to resolve it. Anyone could help?

            Discussion Issue on Github

            ===================================

            Update

            After @talonmies 's help, the problem was resolved by resetting the environment with correct version matching among GPU, CUDA, cudnn and tensorflow. Now it works smoothly.

            ...

            ANSWER

            Answered 2021-Jun-15 at 13:04

            Generally, if there are any incompatibility between TF, CUDA and cuDNN version you can observed this behavior.

            For GeForce RTX 3060, support starts from CUDA 11.x. Once you upgrade to TF2.4 or TF2.5 your issue will be resolved.

            For the benefit of community providing tested built configuration

            CUDA Support Matrix

            Source https://stackoverflow.com/questions/67847219

            QUESTION

            Dynamic Library error while using Tensorflow with GPU
            Asked 2021-Jun-15 at 10:13

            I am programming in Python 3.8 with Tensorflow installed along with my natural language processing project. When I want to begin the training phase, I get this message right before I begin...

            ...

            ANSWER

            Answered 2021-Mar-10 at 14:44

            I would suggest you to use conda (Ananconda/Miniconda) to create a separate environment and install tensorflow-gpu, cudnn and cudatoolkit. Miniconda has a much smaller footprint than Anaconda. I would suggest you to install Miniconda if you do not have conda already.

            Quick Installtion

            Source https://stackoverflow.com/questions/66553987

            QUESTION

            How to add several binary classifiers at the end of a MLP with Keras?
            Asked 2021-Jun-15 at 02:43

            Say I have an MLP that looks like:

            ...

            ANSWER

            Answered 2021-Jun-15 at 02:43

            In your problem you are trying to use Sequential API to create the Model. There are Limitations to Sequential API, you can just create a layer by layer model. It can't handle multiple inputs/outputs. It can't be used for Branching also.

            Below is the text from Keras official website: https://keras.io/guides/functional_api/

            The functional API makes it easy to manipulate multiple inputs and outputs. This cannot be handled with the Sequential API.

            Also this stack link will be useful for you: Keras' Sequential vs Functional API for Multi-Task Learning Neural Network

            Now you can create a Model using Functional API or Model Sub Classing.

            In case of functional API Your Model will be

            Assuming Output_1 is classification with 17 classes Output_2 is calssification with 2 classes and Output_3 is regression

            Source https://stackoverflow.com/questions/67977986

            QUESTION

            Should I trust conda or pip when checking libraries installed?
            Asked 2021-Jun-15 at 00:54

            While I am in a conda environment, the 'conda list' and 'pip freeze' show different number of libraries. For example, 'tensorflow-gpu' is listed in 'pip freeze', but not in 'conda list'. If I want to use tensorflow-gpu in this environment, should I run pip install tensorflow-gpu to install it again, or not necessary?

            ...

            ANSWER

            Answered 2021-Jun-15 at 00:54

            I think when you are using the conda environment. The conda list is going to show all the general packages that shared by the same conda environment. And the reason why 'tensorflow-gpu' is listed in 'pip freeze', but not in 'conda list', is because you used pip install to installed 'tensorflow-gpu'(could be you or the IDE). In this case, 'tensorflow-gpu' is only exists under this python project I believe. Actually, there is an official document about this topic.

            Issues may arise when using pip and conda together. When combining conda and pip, it is best to use an isolated conda environment. Only after conda has been used to install as many packages as possible should pip be used to install any remaining software. If modifications are needed to the environment, it is best to create a new environment rather than running conda after pip. When appropriate, conda and pip requirements should be stored in text files.

            Use pip only after conda Install as many requirements as possible with conda then use pip.

            Pip should be run with --upgrade-strategy only-if-needed (the default).

            Do not use pip with the --user argument, avoid all users installs.

            And here is the link.

            Source https://stackoverflow.com/questions/67978212

            QUESTION

            Tensorflow ValueError: Dimensions must be equal: LSTM+MDN
            Asked 2021-Jun-14 at 19:07

            I am trying to make a next-word prediction model with LSTM + Mixture Density Network Based on this implementation(https://www.katnoria.com/mdn/).

            Input: 300-dimensional word vectors*window size(5) and 21-dimensional array(c) representing topic distribution of the document, used to train hidden initial states.

            Output: mixing coefficient*num_gaussians, variance*num_gaussians, mean*num_gaussians*300(vector size)

            x.shape, y.shape, c.shape with an experimental 161 obserbations gives me such:

            (TensorShape([161, 5, 300]), TensorShape([161, 300]), TensorShape([161, 21]))

            ...

            ANSWER

            Answered 2021-Jun-14 at 19:07

            for MDN model , the likelihood for each sample has to be calculated with all the Gaussians pdf , to do that I think you have to reshape your matrices ( y_true and mu) and take advantage of the broadcasting operation by adding 1 as the last dimension . e.g:

            Source https://stackoverflow.com/questions/67965364

            Community Discussions, Code Snippets contain sources that include Stack Exchange Network

            Vulnerabilities

            In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, the `SparseFillEmptyRowsGrad` implementation has incomplete validation of the shapes of its arguments. Although `reverse_index_map_t` and `grad_values_t` are accessed in a similar pattern, only `reverse_index_map_t` is validated to be of proper shape. Hence, malicious users can pass a bad `grad_values_t` to trigger an assertion failure in `vec`, causing denial of service in serving installations. The issue is patched in commit 390611e0d45c5793c7066110af37c8514e6a6c54, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1."
            In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, the implementation of `SparseFillEmptyRowsGrad` uses a double indexing pattern. It is possible for `reverse_index_map(i)` to be an index outside of bounds of `grad_values`, thus resulting in a heap buffer overflow. The issue is patched in commit 390611e0d45c5793c7066110af37c8514e6a6c54, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, the `Shard` API in TensorFlow expects the last argument to be a function taking two `int64` (i.e., `long long`) arguments. However, there are several places in TensorFlow where a lambda taking `int` or `int32` arguments is being used. In these cases, if the amount of work to be parallelized is large enough, integer truncation occurs. Depending on how the two arguments of the lambda are used, this can result in segfaults, read/write outside of heap allocated arrays, stack overflows, or data corruption. The issue is patched in commits 27b417360cbd671ef55915e4bb6bb06af8b8a832 and ca8c013b5e97b1373b3bb1c97ea655e69f31a575, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, by controlling the `fill` argument of tf.strings.as_string, a malicious attacker is able to trigger a format string vulnerability due to the way the internal format use in a `printf` call is constructed. This may result in segmentation fault. The issue is patched in commit 33be22c65d86256e6826666662e40dbdfe70ee83, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In eager mode, TensorFlow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1 does not set the session state. Hence, calling `tf.raw_ops.GetSessionHandle` or `tf.raw_ops.GetSessionHandleV2` results in a null pointer dereference In linked snippet, in eager mode, `ctx->session_state()` returns `nullptr`. Since code immediately dereferences this, we get a segmentation fault. The issue is patched in commit 9a133d73ae4b4664d22bd1aa6d654fec13c52ee1, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, the `data_splits` argument of `tf.raw_ops.StringNGrams` lacks validation. This allows a user to pass values that can cause heap overflow errors and even leak contents of memory In the linked code snippet, all the binary strings after `ee ff` are contents from the memory stack. Since these can contain return addresses, this data leak can be used to defeat ASLR. The issue is patched in commit 0462de5b544ed4731aa2fb23946ac22c01856b80, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, changing the TensorFlow's `SavedModel` protocol buffer and altering the name of required keys results in segfaults and data corruption while loading the model. This can cause a denial of service in products using `tensorflow-serving` or other inference-as-a-service installments. Fixed were added in commits f760f88b4267d981e13f4b302c437ae800445968 and fcfef195637c6e365577829c4d67681695956e7d (both going into TensorFlow 2.2.0 and 2.3.0 but not yet backported to earlier versions). However, this was not enough, as #41097 reports a different failure mode. The issue is patched in commit adf095206f25471e864a8e63a0f1caef53a0e3a6, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In tensorflow-lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, to mimic Python's indexing with negative values, TFLite uses `ResolveAxis` to convert negative values to positive indices. However, the only check that the converted index is now valid is only present in debug builds. If the `DCHECK` does not trigger, then code execution moves ahead with a negative index. This, in turn, results in accessing data out of bounds which results in segfaults and/or data corruption. The issue is patched in commit 2d88f470dea2671b430884260f3626b1fe99830a, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In tensorflow-lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, when determining the common dimension size of two tensors, TFLite uses a `DCHECK` which is no-op outside of debug compilation modes. Since the function always returns the dimension of the first tensor, malicious attackers can craft cases where this is larger than that of the second tensor. In turn, this would result in reads/writes outside of bounds since the interpreter will wrongly assume that there is enough data in both tensors. The issue is patched in commit 8ee24e7949a203d234489f9da2c5bf45a7d5157d, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In tensorflow-lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, a crafted TFLite model can force a node to have as input a tensor backed by a `nullptr` buffer. This can be achieved by changing a buffer index in the flatbuffer serialization to convert a read-only tensor to a read-write one. The runtime assumes that these buffers are written to before a possible read, hence they are initialized with `nullptr`. However, by changing the buffer index for a tensor and implicitly converting that tensor to be a read-write one, as there is nothing in the model that writes to it, we get a null pointer dereference. The issue is patched in commit 0b5662bc, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In tensorflow-lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, if a TFLite saved model uses the same tensor as both input and output of an operator, then, depending on the operator, we can observe a segmentation fault or just memory corruption. We have patched the issue in d58c96946b and will release patch releases for all versions between 1.15 and 2.3. We recommend users to upgrade to TensorFlow 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1.
            In TensorFlow Lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, saved models in the flatbuffer format use a double indexing scheme: a model has a set of subgraphs, each subgraph has a set of operators and each operator has a set of input/output tensors. The flatbuffer format uses indices for the tensors, indexing into an array of tensors that is owned by the subgraph. This results in a pattern of double array indexing when trying to get the data of each tensor. However, some operators can have some tensors be optional. To handle this scenario, the flatbuffer model uses a negative `-1` value as index for these tensors. This results in special casing during validation at model loading time. Unfortunately, this means that the `-1` index is a valid tensor index for any operator, including those that don't expect optional inputs and including for output tensors. Thus, this allows writing and reading from outside the bounds of heap allocated arrays, although only at a specific offset from the start of these arrays. This results in both read and write gadgets, albeit very limited in scope. The issue is patched in several commits (46d5b0852, 00302787b7, e11f5558, cd31fd0ce, 1970c21, and fff2c83), and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1. A potential workaround would be to add a custom `Verifier` to the model loading code to ensure that only operators which accept optional inputs use the `-1` special value and only for the tensors that they expect to be optional. Since this allow-list type approach is erro-prone, we advise upgrading to the patched code.
            In Tensorflow before version 2.4.0, an attacker can pass an invalid `axis` value to `tf.quantization.quantize_and_dequantize`. This results in accessing a dimension outside the rank of the input tensor in the C++ kernel implementation. However, dim_size only does a DCHECK to validate the argument and then uses it to access the corresponding element of an array. Since in normal builds, `DCHECK`-like macros are no-ops, this results in segfault and access out of bounds of the array. The issue is patched in eccb7ec454e6617738554a255d77f08e60ee0808 and TensorFlow 2.4.0 will be released containing the patch. TensorFlow nightly packages after this commit will also have the issue resolved.
            In Tensorflow before version 2.4.0, when the `boxes` argument of `tf.image.crop_and_resize` has a very large value, the CPU kernel implementation receives it as a C++ `nan` floating point value. Attempting to operate on this is undefined behavior which later produces a segmentation fault. The issue is patched in eccb7ec454e6617738554a255d77f08e60ee0808 and TensorFlow 2.4.0 will be released containing the patch. TensorFlow nightly packages after this commit will also have the issue resolved.
            In affected versions of TensorFlow under certain cases, loading a saved model can result in accessing uninitialized memory while building the computation graph. The MakeEdge function creates an edge between one output tensor of the src node (given by output_index) and the input slot of the dst node (given by input_index). This is only possible if the types of the tensors on both sides coincide, so the function begins by obtaining the corresponding DataType values and comparing these for equality. However, there is no check that the indices point to inside of the arrays they index into. Thus, this can result in accessing data out of bounds of the corresponding heap allocated arrays. In most scenarios, this can manifest as unitialized data access, but if the index points far away from the boundaries of the arrays this can be used to leak addresses from the library. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0.
            In affected versions of TensorFlow under certain cases a saved model can trigger use of uninitialized values during code execution. This is caused by having tensor buffers be filled with the default value of the type but forgetting to default initialize the quantized floating point types in Eigen. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0.
            In affected versions of TensorFlow the tf.raw_ops.DataFormatVecPermute API does not validate the src_format and dst_format attributes. The code assumes that these two arguments define a permutation of NHWC. This can result in uninitialized memory accesses, read outside of bounds and even crashes. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0.
            In affected versions of TensorFlow the tf.raw_ops.ImmutableConst operation returns a constant tensor created from a memory mapped file which is assumed immutable. However, if the type of the tensor is not an integral type, the operation crashes the Python interpreter as it tries to write to the memory area. If the file is too small, TensorFlow properly returns an error as the memory area has fewer bytes than what is needed for the tensor it creates. However, as soon as there are enough bytes, the above snippet causes a segmentation fault. This is because the allocator used to return the buffer data is not marked as returning an opaque handle since the needed virtual method is not overridden. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0.
            In TensorFlow release candidate versions 2.4.0rc*, the general implementation for matching filesystem paths to globbing pattern is vulnerable to an access out of bounds of the array holding the directories. There are multiple invariants and preconditions that are assumed by the parallel implementation of GetMatchingPaths but are not verified by the PRs introducing it (#40861 and #44310). Thus, we are completely rewriting the implementation to fully specify and validate these. This is patched in version 2.4.0. This issue only impacts master branch and the release candidates for TF version 2.4. The final release of the 2.4 release will be patched.
            In affected versions of TensorFlow running an LSTM/GRU model where the LSTM/GRU layer receives an input with zero-length results in a CHECK failure when using the CUDA backend. This can result in a query-of-death vulnerability, via denial of service, if users can control the input to the layer. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0.

            Install TensorFlow

            You can download it from GitHub.
            You can use TensorFlow like any standard Python library. You will need to make sure that you have a development environment consisting of a Python distribution including header files, a compiler, pip, and git installed. Make sure that your pip, setuptools, and wheel are up to date. When using pip it is generally recommended to install packages in a virtual environment to avoid changes to the system.

            Support

            For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .
            Find more information at:

            Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from over 650 million Knowledge Items

            Find more libraries
            CLONE
          • HTTPS

            https://github.com/paramsingh96/TensorFlow.git

          • CLI

            gh repo clone paramsingh96/TensorFlow

          • sshUrl

            git@github.com:paramsingh96/TensorFlow.git

          • Stay Updated

            Subscribe to our newsletter for trending solutions and developer bootcamps

            Agree to Sign up and Terms & Conditions

            Share this Page

            share link