Deep learning train large numbers - python
When I try to create model to predict this data. I can't get good loss. How can I optimize it?
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
X = np.array([32878265.2, 39635188.8, 738222697.41, 33921812.23, 39364408, 50854015, 50938146.63, 54062184.4, 32977734, 27267164, 30673902.72])
y = np.array([80712, 111654, 127836.61, 128710, 147907, 152862, 154962, 138503, 140238, 105121, 113211.8])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.1)
scaler = preprocessing.StandardScaler().fit(X_train.reshape(-1, 1))
X_scaled = scaler.transform(X_train.reshape(-1, 1))
tf.random.set_seed(42)
model = tf.keras.Sequential([
# tf.keras.layers.Dense(10),
tf.keras.layers.Dense(1, input_shape=[1]),
tf.keras.layers.Dense(1),
])
model.compile(loss=tf.keras.losses.mae,
optimizer=tf.keras.optimizers.Adam(),
metrics=["mae"])
model.fit(X_scaled, y_train, epochs=5000,
validation_data=(X_test, y_test))
Epoch 2466/5000 1/1 [==============================] - 0s 29ms/step -
loss: 38000588.0000 - mae: 38000588.0000 - val_loss: 28384532.0000 -
val_mae: 28384532.0000 Epoch 2467/5000 1/1
[==============================] - 0s 31ms/step - loss: 38000588.0000
mae: 38000588.0000 - val_loss: 28384536.0000 - val_mae: 28384536.0000 Epoch 2468/5000 1/1 [==============================] - 0s 41ms/step - loss: 38000588.0000 - mae: 38000588.0000 - val_loss:
28384540.0000 - val_mae: 28384540.0000 Epoch 2469/5000 1/1 [==============================] - 0s 41ms/step - loss: 38000588.0000
mae: 38000588.0000 - val_loss: 28384536.0000 - val_mae: 28384536.0000
Your NN model is just a linear regression. When you plot the data, you see that you have an outlier which is the main problem for a good prediction:
I guess, you typed a digit too much.
Related
Evaluation accuracy stays the same while test accuracy increases just fine
I have tried over and over with different approaches to building this model however I continue to run into this issue where my training accuracy steadily increases just fine but my validation and evaluation accuracy remains very low (55% - 65%). Epoch 95/100 119/119 [==============================] - 0s 2ms/step - loss: 0.6326 - accuracy: 0.8057 - val_loss: 2.0461 - val_accuracy: 0.5985 Epoch 96/100 119/119 [==============================] - 0s 2ms/step - loss: 0.6485 - accuracy: 0.7990 - val_loss: 1.9512 - val_accuracy: 0.5909 Epoch 97/100 119/119 [==============================] - 0s 2ms/step - loss: 0.6263 - accuracy: 0.8032 - val_loss: 2.0344 - val_accuracy: 0.5682 Epoch 98/100 119/119 [==============================] - 0s 2ms/step - loss: 0.6249 - accuracy: 0.7990 - val_loss: 2.0183 - val_accuracy: 0.5682 Epoch 99/100 119/119 [==============================] - 0s 2ms/step - loss: 0.6189 - accuracy: 0.8007 - val_loss: 2.0818 - val_accuracy: 0.5758 Epoch 100/100 119/119 [==============================] - 0s 2ms/step - loss: 0.6261 - accuracy: 0.8024 - val_loss: 2.0591 - val_accuracy: 0.5833 18/18 [==============================] - 0s 1ms/step - loss: 2.2385 - accuracy: 0.5628 EVAL: [2.238506317138672, 0.5628318786621094] The entire script is as follows: import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from keras import Sequential from keras.layers import Dense, Dropout from keras.optimizers import Adam import numpy as np from keras.utils import to_categorical def count_classes(y: list): counts = {} for i in y: if i in counts.keys(): counts[i] += 1 else: counts[i] = 1 return counts dataset = pd.read_csv('Dementia-data.csv') X= dataset.iloc[:,1:] y= dataset.iloc[:,0] # roughly 2562 input variables X.head(2) #standardizing the input feature X_train, X_test, y_train, y_test = train_test_split(X, y, shuffle = True, random_state = 0, test_size=0.2) print("TRAIN:") print(count_classes(list(y_train))) print("TEST:") print(count_classes(list(y_test))) sc = StandardScaler() scaler = sc.fit(X_train) X_train = scaler.transform(X_train) X_test = scaler.transform(X_test) optimizer = Adam(lr=0.00005) classifier = Sequential() #First Hidden Layer classifier.add(Dense(32, activation='relu', kernel_initializer='random_normal', kernel_regularizer=regularizers.l2(0.005), input_dim=2562)) #Second Hidden Layer classifier.add(Dropout(0.2)) classifier.add(Dense(64, activation='relu', kernel_initializer='random_normal', kernel_regularizer=regularizers.l2(0.005))) #Output Layer classifier.add(Dropout(0.2)) classifier.add(Dense(64, activation='relu', kernel_initializer='random_normal')) classifier.add(Dense(7, activation='softmax', kernel_initializer='random_normal')) #Compiling the neural network classifier.compile(optimizer =optimizer,loss='sparse_categorical_crossentropy', metrics =['accuracy']) #Fitting the data to the training dataset classifier.fit(X_train,y_train, batch_size=20, epochs=200, validation_split=0.1, shuffle=True) eval_model=classifier.evaluate(X_test, y_test) print("EVAL:") print(eval_model) I have tried all sorts of things to try to combat overfittings such as regulators, dropouts, and data splitting because that seems to be the lead cause for problems like this one. I do not know if I am missing something. The class distribution for the test and train data is as follows, it doesn't look like there is any inconsistencies between the 2 datasets in terms of ratios of classses: TRAIN: {2: 822, 4: 136, 6: 229, 5: 184, 3: 76, 1: 57} TEST: {2: 199, 6: 59, 5: 45, 1: 26, 3: 15, 4: 33} The plotted accuracy for training and testing: The plotted loss for training and testing, the loss clearly increases for the testing data: I have been struggling with this for weeks now and I'd truly appreciate any help to get this working. I have also tried using learning rates between 0.05 and 0.00005 with little to no improvement.
ANN regression problem with high loss - Python Pandas
I try to run an artificial neural network with 2 parameters in input that can give me the value of the command. An example of the dataset in CSV file: P1,P2,S 7.03,3.36,787.75 6.11,3.31,491.06 5.92,3.34,480.4 5.0,3.39,469.77 5.09,3.36,481.14 5.05,3.35,502.2 4.97,3.38,200.75 5.01,3.34,464.36 5.0,3.42,475.1 4.94,3.36,448.8 4.97,3.37,750.3 5.1,3.39,344.93 5.03,3.41,199.75 5.03,3.39,484.35 5.0,3.47,483.17 4.91,3.42,485.29 3.65,3.51,513.81 5.08,3.47,443.94 5.06,3.4,473.77 5.0,3.42,535.78 3.45,3.44,483.23 4.94,3.45,449.49 4.94,3.51,345.14 5.05,3.48,2829.14 5.01,3.45,1465.58 4.96,3.45,1404.53 3.35,3.58,453.09 5.09,3.47,488.02 5.12,3.52,451.12 5.15,3.54,457.48 5.07,3.53,458.07 5.11,3.5,458.69 5.11,3.47,448.13 5.01,3.42,474.44 4.92,3.44,443.44 5.08,3.53,476.89 5.01,3.49,505.67 5.01,3.47,451.82 4.95,3.49,460.96 5.14,3.42,422.13 5.14,3.42,431.44 5.03,3.46,476.09 4.95,3.53,486.88 5.03,3.42,489.81 5.07,3.45,544.39 5.01,3.52,630.21 5.16,3.49,484.47 5.03,3.52,450.83 5.12,3.48,505.6 5.13,3.54,8400.34 4.99,3.49,615.57 5.13,3.46,673.72, 5.19,3.52,522.31 5.11,3.52,417.29 5.15,3.49,454.97 4.96,3.55,3224.72 5.12,3.54,418.85 5.06,3.53,489.87 5.05,3.45,433.04, 5.0,3.46,491.56 12.93,3.48,3280.98 5.66,3.5,428.5 4.98,3.59,586.43 4.96,3.51,427.67 5.06,3.54,508.53 4.88,3.49,1040.43 5.11,3.52,467.79 5.18,3.54,512.79 5.11,3.52,560.05 5.08,3.53,913.69 5.12,3.53,521.1 5.15,3.52,419.24 5.12,3.56,527.72 5.03,3.52,478.1 5.1,3.55,450.32 5.08,3.53,451.12 4.89,3.53,514.78 4.92,3.46,469.23 5.03,3.53,507.8 4.96,3.56,2580.22 4.99,3.52,516.24 5.0,3.55,525.96 3.66,3.61,450.69 4.91,3.53,487.98 4.97,3.54,443.86 3.53,3.57,628.8 5.02,3.51,466.91 6.41,3.46,430.19 5.0,3.58,589.98 5.06,3.55,711.22 5.26,3.55,2167.16 6.59,3.53,380.59 6.12,3.47,723.56 6.08,3.47,404.59 6.09,3.49,509.5 5.75,3.52,560.21 5.11,3.58,414.83 5.56,3.17,411.22 6.66,3.26,219.38 5.52,3.2,422.13 7.91,3.22,464.87 7.14,3.2,594.18 6.9,3.21,491.0 6.98,3.28,642.09 6.39,3.22,394.49 5.82,3.19,616.82 5.71,3.13,479.6 5.31,3.1,430.6 6.19,3.34,435.42 4.88,3.42,518.14 4.88,3.36,370.93 4.88,3.4,193.36 5.11,3.47,430.06 4.77,3.46,379.38 5.34,3.39,465.39 6.27,3.29,413.8 6.22,3.19,633.28 5.22,3.45,444.14 4.08,3.42,499.91 3.57,3.48,534.41 4.1,3.48,373.8 4.13,3.49,443.57 4.07,3.48,463.74 4.13,3.46,419.92 4.21,3.44,457.76 4.13,3.41,339.31 4.23,3.51,893.39 4.11,3.45,392.54 4.99,3.44,472.96 4.96,3.45,192.54 5.0,3.48,191.22 5.25,3.43,425.64 5.11,3.41,191.12 5.06,3.44,422.32 5.08,3.44,973.29 5.23,3.43,400.67 5.15,3.44,404.2 6.23,3.46,383.07 6.07,3.37,484.3 6.17,3.44,549.94 4.7,3.45,373.43 5.56,3.41,379.33 5.12,3.45,357.51 5.87,3.42,349.89 5.49,3.44,374.4 5.14,3.44,361.11 6.09,3.46,521.23 5.68,3.5,392.98 5.04,3.44,406.9 5.07,3.42,360.8 5.14,3.38,406.48 4.14,3.56,362.45 4.09,3.48,421.83 4.1,3.48,473.64 4.04,3.53,378.35 4.16,3.47,424.59 4.07,3.47,366.27 3.53,3.59,484.37 4.07,3.51,417.12 4.21,3.49,2521.87 4.15,3.5,458.69 4.08,3.52,402.48 4.2,3.47,373.26 3.69,3.5,486.62 4.24,3.51,402.12 4.19,3.5,414.79 4.13,3.55,390.08 4.2,3.5,452.96 4.06,3.52,524.97 4.22,3.47,442.46 4.07,3.5,403.13 4.07,3.51,404.54 4.17,3.46,393.33 4.1,3.4,430.81 4.05,3.41,365.2 4.11,3.47,412.8 4.13,3.49,431.14 4.03,3.51,417.5 3.9,3.48,386.62 4.16,3.49,351.71 5.18,3.48,351.43 4.49,3.5,336.33 3.7,3.51,551.8 6.39,3.44,369.79 6.74,3.35,408.57 6.0,3.38,2924.54 6.61,3.36,449.27 4.91,3.42,361.8 5.81,3.43,470.62 5.8,3.48,389.52 4.81,3.45,403.57 5.75,3.43,570.8 5.68,3.42,405.9 5.9,3.4,458.53 6.51,3.45,374.3 6.63,3.38,406.68 6.85,3.35,382.9 6.8,3.46,398.47 4.81,3.47,398.39 8.3,3.48,538.2 The code : import pandas as pd import matplotlib.pyplot as plt plt.style.use('ggplot') concatenation = pd.read_csv('concatenation.csv') X = concatenation.iloc[:, :2].values # 2 columns y = concatenation.iloc[:, 2].values # 1 column from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0) from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense model = Sequential() model.add(Dense(units=128, activation='relu')) model.add(Dense(units=64, activation='relu')) model.add(Dense(units=1, activation='linear')) model.compile(loss='mean_squared_error', optimizer='adam') model.fit(X_train, y_train, epochs= 1000) But I have a problem during the training, I have high loss, I can not understand why? Epoch 1/1000 10/10 [==============================] - 1s 22ms/step - loss: 407736.7188 - mae: 431.3878 - val_loss: 269746.6875 - val_mae: 380.4598 Epoch 2/1000 10/10 [==============================] - 0s 7ms/step - loss: 407391.1875 - mae: 431.0146 - val_loss: 269452.0625 - val_mae: 380.0934 Epoch 3/1000 10/10 [==============================] - 0s 8ms/step - loss: 407016.3750 - mae: 430.5912 - val_loss: 269062.3125 - val_mae: 379.6077 Epoch 4/1000 10/10 [==============================] - 0s 7ms/step - loss: 406472.7188 - mae: 430.0183 - val_loss: 268508.0312 - val_mae: 378.9190 Epoch 5/1000 10/10 [==============================] - 0s 9ms/step - loss: 405686.1562 - mae: 429.1566 - val_loss: 267709.7812 - val_mae: 377.9213 ... I checked that I didn't have a null value, I standardized my X_train I didn't touch the outputs and I am well in case of regression with the right optimizer and the right loss function... so I can't understand why
What is the calculation process of loss functions in multi-class multi-label classification problems using deep learning?
Dataset description: (1) X_train: (6000,4) shape (2) y_train: (6000,4) shape (3) X_validation: (2000,4) shape (4) y_validation: (2000,4) shape (5) X_test: (2000,4) shape (6) y_test: (2000,4) shape Relationship between X and Y is shown here For single label classification, the activation function of the last layer is Softmax and the loss function is categorical_crossentrop. And I know the mathematical calculation method for the loss function. And for multi-class multi-label classification problems, the activation function of the last layer is sigmoid, and the loss function is binary_crossentrop. I want to know how the mathematical calculation method of the loss function works It would be a great help to me if you let me know. def MinMaxScaler(data): numerator = data - np.min(data) denominator = np.max(data) - np.min(data) return numerator / (denominator + 1e-5) kki = pd.read_csv(filename,names=['UE0','UE1','UE2','UE3','selected_UE0','selected_UE1','selected_UE2','selected_UE3']) print(kki) def LoadData(file): xy = np.loadtxt(file, delimiter=',', dtype=np.float32) print("Data set length:", len(xy)) tr_set_size = int(len(xy) * 0.6) xy[:, 0:-number_of_UEs] = MinMaxScaler(xy[:, 0:-number_of_UEs]) #number_of_UES : 4 X_train = xy[:tr_set_size, 0: -number_of_UEs] #6000 row y_train = xy[:tr_set_size, number_of_UEs:number_of_UEs*2] X_valid = xy[tr_set_size:int((tr_set_size/3) + tr_set_size), 0:-number_of_UEs] y_valid = xy[tr_set_size:int((tr_set_size/3) + tr_set_size), number_of_UEs:number_of_UEs *2] X_test = xy[int((tr_set_size/3) + tr_set_size):, 0:-number_of_UEs] y_test = xy[int((tr_set_size/3) + tr_set_size):, number_of_UEs:number_of_UEs*2] print("Training X shape:", X_train.shape) print("Training Y shape:", y_train.shape) print("validation x shape:", X_valid.shape) print("validation y shape:", y_valid.shape) print("Test X shape:", X_test.shape) print("Test Y shape:", y_test.shape) return X_train, y_train, X_valid, y_valid, X_test, y_test, tr_set_size X_train, y_train, X_valid, y_valid, X_test, y_test, tr_set_size = LoadData(filename) model = Sequential() model.add(Dense(64,activation='relu', input_shape=(X_train.shape[1],))) model.add(Dense(46, activation='relu')) model.add(Dense(24, activation='relu')) model.add(Dense(12, activation='relu')) model.add(Dense(4, activation= 'sigmoid')) model.compile( loss ='binary_crossentropy', optimizer='adam', metrics=['accuracy']) hist = model.fit(X_train, y_train, epochs=5, batch_size=1, verbose= 1, validation_data=(X_valid, y_valid), callbacks= es) This is a learning process, and even if epochs are repeated, Accuracy does not improve. Epoch 1/10 6000/6000 [==============================] - 14s 2ms/step - loss: 0.2999 - accuracy: 0.5345 - val_loss: 0.1691 - val_accuracy: 0.5465 Epoch 2/10 6000/6000 [==============================] - 14s 2ms/step - loss: 0.1554 - accuracy: 0.4883 - val_loss: 0.1228 - val_accuracy: 0.4710 Epoch 3/10 6000/6000 [==============================] - 14s 2ms/step - loss: 0.1259 - accuracy: 0.4710 - val_loss: 0.0893 - val_accuracy: 0.4910 Epoch 4/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.1094 - accuracy: 0.4990 - val_loss: 0.0918 - val_accuracy: 0.5540 Epoch 5/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.0967 - accuracy: 0.5223 - val_loss: 0.0671 - val_accuracy: 0.5405 Epoch 6/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.0910 - accuracy: 0.5198 - val_loss: 0.0836 - val_accuracy: 0.5380 Epoch 7/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.0870 - accuracy: 0.5348 - val_loss: 0.0853 - val_accuracy: 0.5775 Epoch 8/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.0859 - accuracy: 0.5518 - val_loss: 0.0515 - val_accuracy: 0.6520 Epoch 9/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.0792 - accuracy: 0.5508 - val_loss: 0.0629 - val_accuracy: 0.4350 Epoch 10/10 6000/6000 [==============================] - 13s 2ms/step - loss: 0.0793 - accuracy: 0.5638 - val_loss: 0.0632 - val_accuracy: 0.6270
Mistake 1 - The shape of y_train, y_validation and y_test should be (6000,), (2000,) and (2000,) respectively. Mistake 2 - For multi-class classification, the loss should be categorical_crossentropy and activation should be a softmax. So, change these two lines, like this: model.add(Dense(4, activation= 'softmax')) model.compile(loss ='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) Suggestion - Why are you splitting data by yourself? Use scikit-learn train_test_split. This code will give you proper splits: from sklearn.model_selection import train_test_split x, x_test, y, y_test = train_test_split(xtrain, labels, test_size=0.2, train_size=0.8) x_train, x_validation, y_train, y_validation = train_test_split(x, y, test_size = 0.25, train_size =0.75)
Loss is very big from the beginning, and almost not decreasing in tensorflow
I am trying to perform linear regression in tensorflow. I don't understand why from the beginning my loss is so big. What is more, the decrease in loss is very small during training. Could you please tell me if there are any mistakes in my code that may cause this problem? If it is important, I used Kaggle dataset - "House price prediction" - which can be found at kaggle at /shree1992/housedata. I paste my code below: import sys import tensorflow as tf import numpy as np import pandas as pd np.set_printoptions(threshold=sys.maxsize) import numpy as np import matplotlib.pyplot as plt # Loading and inspecting the data: data = pd.read_csv('dataset/data.csv') print(data.head(1)) data = data.drop('street', 1) data = data.drop('statezip', 1) print(data.head(1)) # Encoding categorical data - street, city, statezip, country: data = pd.get_dummies(data, columns=["city", "country"]) data = data.values X = np.array(data[:, 2:], dtype=np.float) Y = np.array(data[:, 1], dtype=np.float) print(X.shape) # it had 4600 observations, 4659 features before dropping two columns - (4600, 57) #after dropping 'street' and 'statezip' - (4600, 57) # Splitting the data into training and test sets from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3) N, D = X_train.shape # Scaling the data from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_train = scaler.fit_transform(X_train) X_test = scaler.transform(X_test) # Creating a model model = tf.keras.models.Sequential([ tf.keras.layers.Input(shape=(D,)), tf.keras.layers.Dense(1) ]) model.compile(optimizer=tf.keras.optimizers.SGD(0.001, 0.9), loss='mse') # model.compile(optimizer='adam', loss='mse') # learning rate scheduler def schedule(epoch, lr): if epoch >= 50: return 0.0001 return 0.001 scheduler = tf.keras.callbacks.LearningRateScheduler(schedule) # Train the model r = model.fit(X_train, y_train, epochs=200, callbacks=[scheduler]) Below you can find a fragment of results of running this code: Epoch 38/200 101/101 [==============================] - 0s 464us/step - loss: 270232453120.0000 Epoch 39/200 101/101 [==============================] - 0s 464us/step - loss: 270549336064.0000 Epoch 40/200 101/101 [==============================] - 0s 464us/step - loss: 270402207744.0000 Epoch 41/200 101/101 [==============================] - 0s 619us/step - loss: 270913732608.0000 Epoch 42/200 101/101 [==============================] - 0s 464us/step - loss: 271168536576.0000 Epoch 43/200 101/101 [==============================] - 0s 464us/step - loss: 270916206592.0000 Epoch 44/200 101/101 [==============================] - 0s 464us/step - loss: 272359129088.0000 Epoch 45/200 101/101 [==============================] - 0s 619us/step - loss: 271552167936.0000 Epoch 46/200 101/101 [==============================] - 0s 464us/step - loss: 272676618240.0000 Epoch 47/200 101/101 [==============================] - 0s 619us/step - loss: 272397254656.0000 Epoch 48/200 101/101 [==============================] - 0s 464us/step - loss: 270996291584.0000 Epoch 49/200 101/101 [==============================] - 0s 619us/step - loss: 271571435520.0000 Epoch 50/200 101/101 [==============================] - 0s 464us/step - loss: 272347545600.0000 Epoch 51/200 101/101 [==============================] - 0s 619us/step - loss: 269679640576.0000
How can I calculate precision, recall and F1-score in Neural Network models?
I'm using Keras to predict if I'll get an output of 1 or 0. The data looks like this: funded_amnt emp_length avg_cur_bal num_actv_rev_tl loan_status 10000 5.60088 19266 2 1 13750 5.60088 2802 6 0 26100 10.0000 19241 17 1 The target is loan_status and the features are the remaining. I've normalized the data before starting to build a Neural Network model. Here's the shape of my training and testing data: print(X_train.shape,Y_train.shape) # Output: (693, 4) (693,) print(X_test.shape,Y_test.shape) # Output: (149, 4) (149,) The process I followed to build the Neural Network is: # define the keras model model = Sequential() model.add(Dense(4, input_dim=4,activation='relu')) model.add(Dense(4 ,activation='relu')) model.add(Dense(1,activation='sigmoid')) # compile the keras model model.compile(loss='binary_crossentropy',optimizer='adam', metrics=['accuracy']) # fit the keras model on the dataset hist = model.fit(X_train, Y_train, validation_data=(X_test, Y_test) ,epochs=10, batch_size=2) The output after running hist: Epoch 1/20 693/693 [==============================] - 1s 2ms/step - loss: 0.5974 - acc: 0.7605 - val_loss: 0.5499 - val_acc: 0.7785 Epoch 2/20 693/693 [==============================] - 0s 659us/step - loss: 0.5369 - acc: 0.7778 - val_loss: 0.5380 - val_acc: 0.7785 Epoch 3/20 693/693 [==============================] - 0s 700us/step - loss: 0.5330 - acc: 0.7778 - val_loss: 0.5369 - val_acc: 0.7785 Epoch 4/20 693/693 [==============================] - 0s 670us/step - loss: 0.5316 - acc: 0.7778 - val_loss: 0.5355 - val_acc: 0.7785 Epoch 5/20 693/693 [==============================] - 0s 720us/step - loss: 0.5307 - acc: 0.7778 - val_loss: 0.5345 - val_acc: 0.7785 Epoch 6/20 693/693 [==============================] - 0s 668us/step - loss: 0.5300 - acc: 0.7778 - val_loss: 0.5339 - val_acc: 0.7785 Epoch 7/20 Now, I would like to calcuate the precision, recall and F1-score instead of just the accuracy. I've tried following this. But I keep getting the following error: ValueError: Classification metrics can't handle a mix of binary and continuous targets Is there another way?
Can you try the following: import numpy as np from keras.callbacks import Callback from sklearn.metrics import confusion_matrix, f1_score, precision_score, recall_score class Metrics(Callback): def on_train_begin(self, logs={}): self.val_f1s = [] self.val_recalls = [] self.val_precisions = [] def on_epoch_end(self, epoch, logs={}): val_predict = (np.asarray(self.model.predict( self.model.validation_data[0]))).round() val_targ = self.model.validation_data[1] _val_f1 = f1_score(val_targ, val_predict) _val_recall = recall_score(val_targ, val_predict) _val_precision = precision_score(val_targ, val_predict) self.val_f1s.append(_val_f1) self.val_recalls.append(_val_recall) self.val_precisions.append(_val_precision) print(f" — val_f1: {_val_f1} — val_precision: {_val_precision} — val_recall _val_recall") return metrics = Metrics() And in your code you need to use it as following: hist = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=10, batch_size=2, callbacks=[metrics])