New answers tagged tensorflow
0
The column df['text'] was of type 'object', which was a byte type, so the pandas Series contained b"foo", etc. The only change to make was to decode the object using: .str.decode('utf-8')
df = tfds.as_dataframe(ds.take(4))
reviews = df['text'].str.decode("utf-8")
corpus = reviews.tolist()
print(corpus)
tokenizer=Tokenizer(num_words=100)
...
1
Keras' one_hot function has many limitations. The biggest issue is that the function does not actually do one hot encoding, it does the hashing trick.
One possible fix is to use keras' hashing_trick function. It allows the hashing function to specified. If you pick a stable hashing function like md5, then the values will be consistent across runs.
Here is an ...
1
You can find exactly that at this site, which offers a handwritten digit recognizer as a static site served from github pages.
Here you can find the article describing how the author did it. You can also have a look at the github repo or directly the html file to understand the how it works. The author also released the colab notebook used to train the model....
1
The input of an LSTM is a sequence of vectors. In your case, each of these vectors represents a word encoded as a one-hot vector. One-hot encoding is a way to express a discrete element (e.g. a word) numerically. Each one-hot vector is a vector of length $d$, where $d$ is the total number of words we can represent, and where all positions in the vector are 0 ...
0
I would recommend using the model like this:
import tensorflow_hub as hub
module_url = "https://tfhub.dev/google/universal-sentence-encoder/4"
model = hub.load(module_url)
print ("module %s loaded" % module_url)
def embed(input):
return model(input)
And then:
embed(["This is a nice string!"])
Which would return:
<tf....
0
It is not a multiclass problem.
It is a multilabel problem. Since, you have the clusters of classes you want to get. You just let the network predict multiple classes and segregate them afterwards. In this case, you will have single classification head.
Other way to do it, is to separately derive multiple classes of article, technique and style. In this case,...
1
Let's say you pass in output_shape as a tuple (50, 50, 10) where we can call the values (height, width, channels)` to the lambda layer:
your_layer = tf.keras.layers.Lambda(lambda x: x, output_shape=(50, 50, 3))
The part of the documentation:
If a tuple, it only specifies the first dimension onward;
means that the batch dimensions itself is simple carried ...
6
The main advantage is in domains where you can't fit all of your data into memory.
However, I've seen improvements in performance even in cases where I have all my data into memory. I think two reasons contribute to this:
One is caching, where some operations (e.g. a mapping OP) will be cached and performed only in the first epoch. This, obviously is ...
1
The Euclidean between two images $p$ and $q$ can be calculated as follows:
$d(p, q) = \sqrt{(q_1 - p_1)^2 + (q_2 - p_2)^2 + ... + (q_{49} - p_{49})^2}$
which is the distance between the 49 (7x7) features of the two images.
This should then give you a vector of shape (1024, 1) where each value is the Euclidean distance of the feature maps of the previous ...
0
For TypeErrors it is always good to check the exact type of the variable causing issues, especially when troubleshooting TensorFlow and Keras:
print(type(df['text']))
fit_on_texts expects a list of string or similar, but you are providing a dictionary, so you'll want to convert accordingly. Example:
from typing import List, Dict
foo_dict: Dict[str, str] = {...
1
The normalisation you do does not re-scale to $[0,1]$ range! It normalises to have mean $0$ and std $1$ instead.
To scale the tensor to be in $[0,1]$ range you should subtract min value and divide by absolute max-min value.
0
One approach is to have a dummy class that represents no treatment and use the accuracy score via a threshold (lower than threshold) correspond to no treatment at all.
Threshold as used above becomes a new hyper-parameter and you have new input-output pairs that are now exact (depending on threshold).
1
gaussian is different from sigma, because sigma is trainable while gaussian is not. It implies that the value of sigma can be optimized but not of gaussian.
optimal is different from mse as
in the case of mse, the final loss is computed as MSE.
but in the case of optimal, we use gaussian as the loss function, with MSE acting as the variance of the gaussian ...
0
Given you already have the tf.data.Dataset, one way to do it would be to iterate over the dataset and each time you come across a new label, save that e.g. to a dictionary, otherwise skip an already seen label.
Here is a short example just using the MNIST dataset that comes with tensorflow:
import matplotlib.pyplot as plt
import tensorflow as tf
(x_train, ...
0
Keras included in their library to predict the class label. You can get the class label directly by using model.predict_classes(img).
Ref: https://datascience.stackexchange.com/a/40415/109134
1
The task is a specific case of NER (technically NER is a sequence labeling task, a special case of classification).
I think you would have two main options:
Apply a pre-trained NER model: most deal with time entities but not always very accurately, and it wouldn't be specifically adapted to your data so you wouldn't obtain the distinction between the three ...
0
Model prediction output is a bunch of probabilities. In order to get category name you need use following snippet. It calculates the argmax of predicions and give it to CLASSES list:
print(CLASSES[np.argmax(predictions)])
0
I found a solution that works for me.
Since I wanted to avoid using padding and masking, and didn't fully understand ragged tensors, I decided to continue with using varying input lengths.
My training data consists of a list of image stacks between 6-82 frames. When trying to use this directly with model.fit(x=x, y=y, batch_size=1) where x is a list of ...
0
As the following images from the paper shows, during training time you create patches from larger images. These patches have no defects and can therefore be seen as 'good' images. To get the accompanying 'bad' images with defects you synthetically generate these defects on the 'good' images.
Your data generator should therefore follow the following steps:
...
0
First of all look at the shape of tensors that your tf.data.Dataset returns then try to set the input_shape of the first Dense layer like:
model = keras.Sequential([
layers.Dense(520, activation='relu', input_shape=(1, 519)),
layers.Dense(520, activation='relu'),
layers.Dense(520, activation='relu'),
layers.Dense(1)
])
or explicitly add ...
1
I understand that you are doing only inference, so you shouldn't need your model to be trainable, and therefore you can set the parameter trainable to False when invoking hub.Module.
0
Yes, these type of loss functions can be optimized using backpropagation, also in Tensorflow.
The value of the loss is a scalar (same as just the cross entropy, or the MSE, otherwise you wouldn't be able to add them), which means that it doesn't really work any different from just optimizing for any other scalar loss function. As long as the operations ...
1
There are several options when saving and loading a keras model, as explained at https://www.tensorflow.org/guide/keras/save_and_serialize:
save the whole configuration, including the architecture, weights and even the last training state
but also the model architecture and the weights can be saved as independent files, and that is what you might have ...
0
I find setting the variable outside the script easiest and something that always works.
export CUDA_VISIBLE_DEVICES=''
Run this on the command line before running your python script.
1
The Bayesian optimization algorithm selects points to test based on a balance between exploring uncertain regions and exploiting high-performing regions. But before you've tested very many points, there's not much information to go on. So, in this implementation you can specify a number of completely-at-random points to evaluate to start, and after that ...
0
In one epoch - It's the number of images in your Directory or the DataFrame
In case of a custom Generator. It will be batch_size * steps_per_epoch
You may check this with any of these approaches -
Check the shape of prediction on train model.predict(traindata).shape
Save the images into a dir by using save_to_dir='/content/train_data'
Write a callback for ...
1
Shuffling begins by making a buffer of size BUFFER_SIZE (which starts empty but has enough room to store that many elements). The buffer is then filled until it has no more capacity with elements from the dataset, then an element is chosen uniformly at random. This means that each example in the buffer is equally likely to be chosen, with probability 1/...
0
So I posted this same question on machine learning mastery post about removing trends and seasonality difference transform for time series data. And Jason Brownlee responded to my questions:
Yes, you can use MLP, CNN and LSTM. It requires first converting the
data to a supervised learning problem using a sliding window:
https://machinelearningmastery.com/...
1
You are still able to calculate metrics such as loss and accuracy on training data (or any data for that matter), however the important thing to keep in mind is that it is by definition training data. Therefore the metrics from the training data are not how you would expect the model to perform on new unseen data as the model has been training on these ...
0
Comment above to SO post is spot on. A custom callback, as provided in that post, is the solution and the term 'baseline' is not meant to be interpreted as a threshold.
0
As you stated in your question, those numbers go into a softmax function. Another name for softmax is normalized exponential function. Softmax normalizes numbers where the sum is constrained to be 1 and each value becomes the probability of categorical membership.
In the specific case of [23.4, -21254.3, 32123.4], applying the softmax transforms them to [0, ...
0
This is because the calculation of the loss and accuracy are done before the first weight update (i.e. the model with the initialized parameters). After the loss is calculated the first time the loss is used to backpropagate the error throughout the network and to update the parameters. The loss is not calculated again during training (since this would just ...
0
Also you can use sparse_categorical_crossentropy as loss function, and then you don't need onehot-encoding.
sample code: model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')
more info at Keras website
0
Cross-entropy is an information-theoretic measure about probability distributions, and it's measured in units that are determined by the base of the logarithm used in its computation (nats for the natural logarithm or bits for $log_2$). There are already several posts about intuitive understanding of cross entropy and its relationship to KL divergence (which ...
0
maybe this is better in your case:
class MyModel(Model):
def __init__(self):
super(MyModel, self).__init__()
self.layer_one = Dense(1, name='output_name_one')
self.layer_two = Dense(1, name='output_name_two')
def call(self, inputs):
output_name_one = self.layer_one(inputs)
output_name_two = self.layer_two(...
0
I also have this issue, but didn't have the answer with a customized Model.
There is a workaround as follows:
model = Model(inputs=inputs,
outputs={'ctr_output': ctr_pred, 'ctcvr_pred': ctcvr_pred, 'cvr_output': cvr_pred})
1
A common approach is what you suggest in 1. - apply time-shift as a Data Augmentation strategy. The augmentation is generally beneficial with deep learning models, and GPUs are fast so the compute time is rarely a big problem.
Another strategy, less common, would be to make sure that the event is always located at the same position inside the analysis window ...
0
I was trying to go through the same tutorial and I had the same question in mind. I did some research in the codebase and the docs and have the following pointers.
The tf.random.log_uniform_candidate_sampler function is a sampler that samples classes from an approximately log-uniform or Zipfian distribution. Due to the fact that the words are in a lexicon ...
0
If you understand how a particular type of Layer works, you can simply add them as at the end all of these are Tensor operations.
But you must know what are you doing.
May do this way
from keras.models import Sequential
from keras import layers
model = Sequential()
model.add(layers.LSTM(30, return_sequences=True, input_shape=(30,3)))
model.add(layers....
0
I found a solution that we should use the softmax activation function in the last layer. previously I used the sigmoid activation function
1
My thoughts are to save Keras model to .pb(protobuf) file and then
load this model with Tensorflow C API.
Do you think this will be possible?
the answer is yes, absolutely. there are many ways to do this and i'll list some here so that you can pick up what suites your needs.
you can use cppflow, which is a c++ wrapper for the tensorflow C API, and actually ...
0
Keras should be accessed as tf.keras now with tf2 ,so your import should be written as
tf.keras.callbacks.ModelCheckpoint
Keras own documentation as well as tf api documentation can be easily accessed for this purpose. Keras ModelCheckpoint class mentions the following arguments in official docs:
save_best_only: if save_best_only=True, it only saves when ...
Top 50 recent answers are included
