Neural Networks Beginnings. Jade Carter

= 0.01

      num_epochs = 1000

      #initialize user and item matrices

      user_matrix = np.random.normal(scale=1./num_factors, size=(num_users, num_factors))

      item_matrix = np.random.normal(scale=1./num_factors, size=(num_factors, num_items))

      #matrix factorization training

      for epoch in range(num_epochs):

      for i in range(num_users):

      for j in range(num_items):

      if ratings[i][j] > 0:

      error = ratings[i][j] – np.dot(user_matrix[i,:], item_matrix[:,j])

      user_matrix[i,:] += learning_rate * (error * item_matrix[:,j])

      item_matrix[:,j] += learning_rate * (error * user_matrix[i,:])

      #predict ratings for all users and items

      predicted_ratings = np.dot(user_matrix, item_matrix)

      #recommend items for a specific user

      user_id = 0

      recommended_items = np.argsort(predicted_ratings[user_id])[::-1]

      print("Recommendations for user", user_id)

      print(recommended_items)

      In this example, we used matrix factorization to build a recommender system. We initialized user and item matrices with random values and trained them based on known user and item ratings. We then used the obtained matrices to predict ratings for all users and items, and then recommended items based on these predictions for a specific user. In real systems, more complex algorithms and more diverse data can be used.

      4. Automatic emotion detection.

      Process description.

      We import the necessary modules from TensorFlow.

      We create a model using convolutional neural networks. The model takes input data in the form of a 48x48x1 pixel image. Conv2D, BatchNormalization, and MaxPooling2D layers are used to extract features from the image. The Flatten layer converts the obtained features into a one-dimensional vector. Dense, BatchNormalization, and Dropout layers are used to classify emotions into 7 categories (happiness, sadness, anger, etc.). We compile the model, specifying the optimizer, loss function, and metrics. We train the model on the training dataset using the validation dataset.We evaluate the accuracy of the model on the testing dataset. We use the model to predict emotions on new data.

      import tensorflow as tf

      from tensorflow import keras

      from tensorflow.keras import layers

      # Creating a model

      model = keras.Sequential([

       layers.Conv2D(32, (3, 3), activation='relu', input_shape=(48, 48, 1)),

       layers.BatchNormalization(),

       layers.MaxPooling2D(pool_size=(2, 2)),

       layers.Dropout(0.25),

       layers.Conv2D(64, (3, 3), activation='relu'),

       layers.BatchNormalization(),

       layers.MaxPooling2D(pool_size=(2, 2)),

       layers.Dropout(0.25),

       layers.Conv2D(128, (3, 3), activation='relu'),

       layers.BatchNormalization(),

       layers.MaxPooling2D(pool_size=(2, 2)),

       layers.Dropout(0.25),

       layers.Flatten(),

       layers.Dense(256, activation='relu'),

       layers.BatchNormalization(),

       layers.Dropout(0.5),

       layers.Dense(7, activation='softmax')

      ])

      # Compiling the model.

      model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

      # Training the model

      history = model.fit(train_data, train_labels, epochs=50, validation_data=(val_data, val_labels))

      # Evaluation of the model

      test_loss, test_acc = model.evaluate(test_data, test_labels)

      print('Test accuracy:', test_acc)

      # Using the model

      predictions = model.predict(new_data)

      This code creates a convolutional neural network for recognizing emotions on 48x48 pixel images.

      The first layer uses a 3x3 convolution with 32 filters and a ReLU activation function that takes 48x48x1 input images. Then follow layers of batch normalization, max pooling with a 2x2 filter size, and dropout to help prevent overfitting.

      Two additional convolutional layers with increased filter numbers and similar normalization and dropout layers are then added. A flattening layer follows, which converts the multidimensional input to a one-dimensional vector.

      Next are two fully connected layers with ReLU activation and batch normalization, as well as dropout layers. The final layer contains 7 neurons and uses the softmax activation function to determine the probability of each of the 7 emotions.

      The optimizer Adam, the categorical_crossentropy loss function, and the accuracy metric are used to compile the model. The model is trained on the training data for 50 epochs with validation on the validation data.

      After training, the model is evaluated on the test data, and the accuracy of predictions is displayed. Then the model is used to predict emotions on new data.

      Conclusion on Chapter 1:

      In this chapter, we have covered the fundamental concepts underlying neural networks. We learned what a neuron is, how it works in a neural network, what weights and biases are, how a neuron makes decisions, and how a neural network is constructed. We also discussed the process of training a neural network and how it adjusts its weights and biases to improve prediction accuracy.