DataBloom

Yesterday, I installed the latest CUDA toolkit (11.2), but
TensorFlow said there was no cudart64_110.dll file. So, I then
installed CUDA toolkit 11.0, which has this file, but TensorFlow
still cannot find the file.

I am running Windows 10 Home Edition.

I’m rather quite embarrassed recently for flooding this forum
thread with mostly novice questions. I’m still a newbie, still
struggling to figure out how the code works in TensorFlow. Pardon
me for doing that. Is there any template code where I can compute
and display the loss and accuracy of the trained model on the test
set?

My AI model doesn’t provide me with ‘accuracy’, it always say
its 0. Why is that?

my code:

(the data i use to train is just a list of a few thousand high
prices of BTC)

# split a univariate sequence into samples
def split_sequence(sequence, n_steps):
X, y = list(), list()
for i in tqdm(range(len(sequence)), desc=’Creating training
array’):
# find the end of this pattern
end_ix = i + n_steps
# check if we are beyond the sequence/,010,0,
if end_ix > len(sequence)-1:
break
# gather input and output parts of the pattern
seq_x, seq_y = sequence[i:end_ix], sequence[end_ix]
X.append(seq_x)
y.append(seq_y)
return np.array(X), np.array(y)
def create_training_sequence(price_type=’high’, n_steps=5):
df = pd.read_csv(‘candlesticks.csv’)
df = df.drop([‘Unnamed: 0’, ‘open’, ‘close’, ‘volume’], axis=1)
if price_type == ‘high’:
sequence = df.drop([‘closeTime’, ‘low’], axis=1)
if price_type == ‘low’:
sequence = df.drop([‘closeTime’, ‘high’], axis=1)
print(sequence.head())

X, Y = split_sequence(sequence[price_type], n_steps)
print(X[1])
# reshape from [samples, timesteps] into [samples, timesteps,
features]
n_features = 1
return X, Y

import tensorflow as TheFuckImDoingHere
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM
from sklearn.model_selection import train_test_split
use_CPU = False
epochs = 100
n_steps = 60
batch_size = n_steps
n_features = 1
x, y = create_training_sequence(n_steps=n_steps)
x_train, x_test, y_train, y_test = train_test_split(x, y,
test_size=0.2)
x_train = x_train.reshape((x_train.shape[0], x_train.shape[1],
n_features))
x_test = x_test.reshape((x_test.shape[0], x_train.shape[1],
n_features))
print(‘————————-‘)
print(‘x_train shape: ‘+str(x_train.shape)+’, x_test shape:
‘+str(x_test.shape))
print(‘————————-‘)
if use_CPU == True:
#limit ram and cpu usage
TheFuckImDoingHere.config.threading.set_intra_op_parallelism_threads(2)
TheFuckImDoingHere.config.threading.set_inter_op_parallelism_threads(2)
# define model
model = Sequential()
model.add(LSTM(64, activation=’relu’, return_sequences=True,
input_shape=(n_steps, n_features)))
model.add(LSTM(128, activation=’relu’, return_sequences=True))
model.add(LSTM(256, activation=’relu’, return_sequences=True))
model.add(LSTM(128, activation=’relu’, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(64, activation=’relu’))
model.add(Dropout(0.2))
model.add(Dense(1))
model.compile(optimizer=’adam’, loss=’mse’, metrics=[‘acc’,
‘mse’])
model.summary()
#
callback = TheFuckImDoingHere.keras.callbacks.EarlyStopping(
monitor=’val_loss’, min_delta=0, patience=15, verbose=1,
mode=’min’, baseline=None, restore_best_weights=False)
#
# fit model
if use_CPU == True:
# Run inference on CPU
with TheFuckImDoingHere.device(‘/CPU:0’):
hist = model.fit(x_train, y_train, epochs=epochs,
batch_size=batch_size, validation_data=(x_test, y_test),
callbacks=[callback])
elif use_CPU == False:
# Run inference on GPU
with TheFuckImDoingHere.device(‘/GPU:0’):
hist = model.fit(x_train, y_train, epochs=epochs,
batch_size=batch_size, validation_data=(x_test, y_test),
callbacks=[callback])
prediction = model.predict(x_test[0].reshape((1, x_train.shape[1],
n_features)), verbose=0)
print(‘Prediction is: ‘ + str(prediction))
print(‘Real value is: ‘ + str(y_test[0]))
#print evaluation
loss1, acc1, mse1 = model.evaluate(x_test, y_test)
print(f”Loss is {loss1:.20E},nAccuracy is {float(acc1)*100},nMSE
is {mse1:.8E}”)

why google

My code is

def get_checkpoint_every_epoch(): checkpoint_every_epoch = 'model_checkpoints_every_epoch' checkpoints = ModelCheckpoint(filepath=checkpoint_every_epoch, frequency= 'epoch', save_weights_only=True, verbose=1) return checkpoints def get_checkpoint_best_only(): checkpoint_best_path = 'model_checkpoints_best_only/checkpoint' checkpoint_best= ModelCheckpoint(filepath=checkpoint_best_path, save_weights_only= True, monitor= 'val_accuracy', save_best_only= True, verbose=1) return checkpoint_best def get_early_stopping(): early_stopping= tf.keras.callbacks.EarlyStopping(monitor='val_accuracy', patience=3) return early_stopping checkpoint_every_epoch = get_checkpoint_every_epoch() checkpoint_best_only = get_checkpoint_best_only() early_stopping = get_early_stopping() 

Followed by this,

def get_model_last_epoch(model): model_last_epoch_file = tf.train.latest_checkpoint("checkpoints_every_epoch") model.load_weights(model_last_epoch_file) return model def get_model_best_epoch(model): model_best_epoch_file = tf.train.latest_checkpoint("checkpoints_best_only") model.load_weights(model_best_epoch_file) return model model_last_epoch = get_model_last_epoch(get_new_model(x_train[0].shape)) model_best_epoch = get_model_best_epoch(get_new_model(x_train[0].shape)) print('Model with last epoch weights:') get_test_accuracy(model_last_epoch, x_test, y_test) print('') print('Model with best epoch weights:') get_test_accuracy(model_best_epoch, x_test, y_test) 

This is where, I get this error:

​

AttributeError Traceback (most recent call last) <ipython-input-18-b6d169507ca4> in <module> 3 # Verify that the second has a higher validation (testing) accuarcy. 4 ----> 5 model_last_epoch = get_model_last_epoch(get_new_model(x_train[0].shape)) 6 model_best_epoch = get_model_best_epoch(get_new_model(x_train[0].shape)) 7 print('Model with last epoch weights:') <ipython-input-17-4c8cba016afe> in get_model_last_epoch(model) 12 model_last_epoch_file = tf.train.latest_checkpoint("checkpoints_every_epoch") 13 ---> 14 model.load_weights(model_last_epoch_file) 15 16 return model /opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training.py in load_weights(self, filepath, by_name) 179 raise ValueError('Load weights is not yet supported with TPUStrategy ' 180 'with steps_per_run greater than 1.') --> 181 return super(Model, self).load_weights(filepath, by_name) 182 183 @trackable.no_automatic_dependency_tracking /opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/network.py in load_weights(self, filepath, by_name) 1137 format. 1138 """ -> 1139 if _is_hdf5_filepath(filepath): 1140 save_format = 'h5' 1141 else: /opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/network.py in _is_hdf5_filepath(filepath) 1447 1448 def _is_hdf5_filepath(filepath): -> 1449 return (filepath.endswith('.h5') or filepath.endswith('.keras') or 1450 filepath.endswith('.hdf5')) 1451 AttributeError: 'NoneType' object has no attribute 'endswith' 

What does it mean? Sorry, I’m just a newbie, need some
enlightenment. I wish you a merry christmas. Thanks a lot!

So I am following a YouTube series here: https://www.youtube.com/watch?v=CA0PQS1Rj_4

And this person also posted their code on GitHub:
https://github.com/musikalkemist/Deep-Learning-Audio-Application-From-Design-to-Deployment/tree/master/4-%20Making%20Predictions%20with%20the%20Speech%20Recognition%20System

(I removed the model.h5 and data.json since I wanted to use a
model generated on my own PC)

I run the train.py which trains the model and get this as a
result: https://pastebin.com/mZSXK25v

When i test the “down.wav”, it predicts “right”: https://pastebin.com/Up8EvNyc

When I tested “left.wav”, it predicts “down”: https://pastebin.com/vzWzTV4X

How come I get different results, in fact completely wrong
results no matter what I test, despite getting a 0.9358
accuracy?