Staggering During Camera Movement

I am trying to get the camera movement very smooth, though I notice there is some staggering here and there and am unsure why. The largest stagger is right at the end of this clip, if you see that you will understand the behaviour I am referring to.
Staggering Movement YouTube Video
My Input Functions:

// Global map object to store flags for all the keys I am keeping track of
std::map <int, bool> keyboardLoggedStatesMap = { 
    {GLFW_KEY_W, false}, 
    {GLFW_KEY_A, false},
    {GLFW_KEY_S, false},
    {GLFW_KEY_D, false} };

// KEYBOARD CALLBACK
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    // key_callback sets flags for key down or key up, then movement logic is calculated elsewhere
    if (action == GLFW_PRESS)
    {
        keyboardLoggedStatesMap[key] = true;
    }
    else if (action == GLFW_RELEASE)
    {
        keyboardLoggedStatesMap[key] = false;
    }
}

// MOUSE CALLBACK
void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {

    if (firstMouse)
    {
        camera.cursor.lastX = xpos;
        camera.cursor.lastY = ypos;
        firstMouse = false;
    }

    camera.cursor.xoffset = (xpos - camera.cursor.lastX) * camera.cursor.sensitivity;
    camera.cursor.yoffset = (camera.cursor.lastY - ypos) * camera.cursor.sensitivity;
    camera.cursor.lastX = xpos;
    camera.cursor.lastY = ypos;

    camera.cursor.yaw += camera.cursor.xoffset;
    camera.cursor.pitch += camera.cursor.yoffset;

    if (camera.cursor.pitch > 89.0f)
        camera.cursor.pitch = 89.0f;
    if (camera.cursor.pitch < -89.0f)
        camera.cursor.pitch = -89.0f;

    camera.front = glm::normalize(glm::vec3(
        cos(glm::radians(camera.cursor.yaw)) * cos(glm::radians(camera.cursor.pitch)),
        sin(glm::radians(camera.cursor.pitch)),
        sin(glm::radians(camera.cursor.yaw)) * cos(glm::radians(camera.cursor.pitch))
    ));
}

// Updates the position of the camera, called once per frame
void processInputs()
{
    // iterate through each element of map object
    for (std::pair<int, bool> pair : keyboardLoggedStatesMap) {
        if (pair.second) // pair.second (a boolean) holds whether the key is pressed down or not, if true it is down
        {
            switch (pair.first) // pair.first holds the particular GLFW keyboard key value in the keyboardLoggedStatesMap
            {
            case GLFW_KEY_W: // FORWARD
                camera.position += camera.speed * camera.front * deltaTime;
                break;
            case GLFW_KEY_S: // BACKWARD
                camera.position -= camera.speed * camera.front * deltaTime;
                break;
            case GLFW_KEY_A: // LEFT
                camera.position -= glm::normalize(glm::cross(camera.front, camera.top)) * camera.speed * deltaTime;
                break;
            case GLFW_KEY_D: // RIGHT
                camera.position += glm::normalize(glm::cross(camera.front, camera.top)) * camera.speed * deltaTime;
                break;
            }
        }
    }
}

Main Loop:

    void mainLoop() {
        while (!glfwWindowShouldClose(window)) {
            deltaTime = std::chrono::duration<float, std::chrono::seconds::period>(std::chrono::high_resolution_clock::now() - std::chrono::high_resolution_clock::now()).count();

            glfwPollEvents();
            processInputs();
            drawFrame();
        }

        vkDeviceWaitIdle(device);
    }

Uniform Buffer Update:

    void updateUniformBuffer(uint32_t currentImage)
    {
        ubo.model = glm::mat4(1.0f);
        ubo.view = glm::lookAt(camera.position, camera.position + camera.front, camera.top);
        ubo.proj = glm::perspective(glm::radians(camera.fov), (*swapChainExtentGlobalAccessCopy).width / (float)(*swapChainExtentGlobalAccessCopy).height, 0.1f, 10.0f);
        ubo.proj[1][1] *= -1;

        memcpy(uniformBuffersMapped[currentImage], &ubo, sizeof(ubo));
    }

Shaders: (vertex and fragment)

#version 450

layout(binding = 0) uniform UniformBufferObject {
    mat4 model;
    mat4 view;
    mat4 proj;
} ubo;

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;

layout(location = 0) out vec3 fragColor;

void main() {
    gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
    fragColor = inColor;
}

#version 450

layout(location = 0) in vec3 fragColor;

layout(location = 0) out vec4 outColor;

void main() {
    outColor = vec4(fragColor, 1.0);
}

All the rest of my code is just copy pasted from the Vulkan tutorial site. How can I make my movement extremely smooth?

Cross-ref: