2TEST is the datawarehouse test automation tool

2TEST

"How Many Colors Can the Human Eye See?": The Application

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com;
(2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com;
(3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. Table of Links Abstract and Introduction
Problem Setup and Related Work
HyperTransformer
Experiments
Conclusion and References
A Example of a Self-Attention Mechanism For Supervised Learning
B Model Parameters
C Additional Supervised Experiments
D Dependence On Parameters and Ablation Studies
E Attention Maps of Learned Transformer Models
F Visualization of The Generated CNN Weights
G Additional Tables and Figures C ADDITIONAL SUPERVISED EXPERIMENTS While the advantage of decoupling parameters of the weight generator and the generated CNN model is expected to vanish with the growing CNN model size, we compared our approach to two other methods, LGM-Net (Li et al., 2019b) and LEO (Rusu et al., 2019), to verify that our approach can match their performance on sufficiently large models. For our comparison with the LGM-Net method, we used the same image augmentation technique that was used in Li et al. (2019b) where it was applied both at the training and the evaluation stages (Ma, 2019). We also used the same CNN architecture with 4 learned 64-channel convolutional layers followed by two generated convolutional layers and the final logits layer. In our weight generator, we used 2-layer transformers with local feature extractors that relied on 48-channel convolutional layers and did not use any global features. We trained our model in the end-to-end fashion on the MINIIMAGENET 1-shot-5-way task and obtained a test accuracy of 69.3% ± 0.3% almost identical to the 69.1% accuracy reported in Li et al. (2019b). We also carried out a comparison with LEO by using our method to generate a fully-connected layer on top of the TIEREDIMAGENET embeddings pre-computed with a WideResNet-28 model employed by Rusu et al. (2019). For our experiments, we used a simpler 1-layer transformer model with 2 heads that did not have the final fully-connected layer and nonlinearity. We also used L2 regularization of the generated fully-connected weights setting the regularization weight to 10−3. As a result of training this model, we obtained 66.2% ± 0.2% and 81.6% ± 0.2% test accuracies on the 1-shot-5-way and 5-shot-5-way TIEREDIMAGENET tasks correspondingly. These results are almost identical to 66.3% and 81.4% accuracies reported in Rusu et al. (2019). This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com; (2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com; (3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com; (2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com; (3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. Table of Links Abstract and Introduction Problem Setup and Related Work HyperTransformer Experiments Conclusion and References A Example of a Self-Attention Mechanism For Supervised Learning B Model Parameters C Additional Supervised Experiments D Dependence On Parameters and Ablation Studies E Attention Maps of Learned Transformer Models F Visualization of The Generated CNN Weights G Additional Tables and Figures Abstract and Introduction Abstract and Introduction Problem Setup and Related Work Problem Setup and Related Work HyperTransformer HyperTransformer Experiments Experiments Conclusion and References Conclusion and References A Example of a Self-Attention Mechanism For Supervised Learning A Example of a Self-Attention Mechanism For Supervised Learning B Model Parameters B Model Parameters C Additional Supervised Experiments C Additional Supervised Experiments D Dependence On Parameters and Ablation Studies D Dependence On Parameters and Ablation Studies E Attention Maps of Learned Transformer Models E Attention Maps of Learned Transformer Models F Visualization of The Generated CNN Weights F Visualization of The Generated CNN Weights G Additional Tables and Figures G Additional Tables and Figures C ADDITIONAL SUPERVISED EXPERIMENTS While the advantage of decoupling parameters of the weight generator and the generated CNN model is expected to vanish with the growing CNN model size, we compared our approach to two other methods, LGM-Net (Li et al., 2019b) and LEO (Rusu et al., 2019), to verify that our approach can match their performance on sufficiently large models. For our comparison with the LGM-Net method, we used the same image augmentation technique that was used in Li et al. (2019b) where it was applied both at the training and the evaluation stages (Ma, 2019). We also used the same CNN architecture with 4 learned 64-channel convolutional layers followed by two generated convolutional layers and the final logits layer. In our weight generator, we used 2-layer transformers with local feature extractors that relied on 48-channel convolutional layers and did not use any global features. We trained our model in the end-to-end fashion on the MINIIMAGENET 1-shot-5-way task and obtained a test accuracy of 69.3% ± 0.3% almost identical to the 69.1% accuracy reported in Li et al. (2019b). We also carried out a comparison with LEO by using our method to generate a fully-connected layer on top of the TIEREDIMAGENET embeddings pre-computed with a WideResNet-28 model employed by Rusu et al. (2019). For our experiments, we used a simpler 1-layer transformer model with 2 heads that did not have the final fully-connected layer and nonlinearity. We also used L2 regularization of the generated fully-connected weights setting the regularization weight to 10−3. As a result of training this model, we obtained 66.2% ± 0.2% and 81.6% ± 0.2% test accuracies on the 1-shot-5-way and 5-shot-5-way TIEREDIMAGENET tasks correspondingly. These results are almost identical to 66.3% and 81.4% accuracies reported in Rusu et al. (2019).

HyperTransformer: C Additional Supervised Experiments

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Sebastien Ferr ´e, Univ Rennes, CNRS, Inria, IRISA Campus de Beaulieu, 35042 Rennes, France and ferre@irisa.fr. Table of Links Abstract & Introduction Abstraction and Reasoning Corpus (ARC) Related Work Object-centric Models for ARC Grids MDL-based Model Learning Evaluation Conclusion and Perspectives, References & Supplementary Materials 2 Abstraction and Reasoning Corpus (ARC) ARC is a collection of tasks3 , where each task is made of training examples (3.3 on average) and test examples (1 in general). Each example is made of an input grid and an output grid. Each grid is a 2D array (with size up to 30x30) filled with integers coding for colors (10 distinct colors). For a given task, the size of grids can vary from one example to another, and between the input and the output. Each task is a machine learning problem, whose goal is to learn a model that can generate the output grid from the input grid, and so from a few training examples only. Prediction is successful only if the predicted output grid is strictly equal to the expected grid for all test examples, there is no partial success. However, three trials are allowed for each test example to compensate for potential ambiguities in the training examples. Figure 1 shows two ARC tasks (with the expected test output grid missing). The first is used as a running example in this paper. We now more formally define grids, examples, and tasks. ARC tasks have 3.3 training examples on average, and 1 or 2 test examples (most often 1). As illustrated by Figure 1, the different input grids of a task need not have the same size, nor use the same colors. The same applies to test grids. ARC is composed of 1000 tasks in total: 400 “training tasks”4 , 400 evaluation tasks, and 200 secret tasks for independent evaluation. Figure 1 shows two of the 400 training tasks. Developers should only look at the training tasks, not at the evaluation tasks. The latter should only be used to evaluate the broad generalization capability of the developed systems. This paper is available on Arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. Authors: (1) Sebastien Ferr ´e, Univ Rennes, CNRS, Inria, IRISA Campus de Beaulieu, 35042 Rennes, France and ferre@irisa.fr. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Sebastien Ferr ´e, Univ Rennes, CNRS, Inria, IRISA Campus de Beaulieu, 35042 Rennes, France and ferre@irisa.fr. Table of Links Abstract & Introduction Abstract & Introduction Abstraction and Reasoning Corpus (ARC) Abstraction and Reasoning Corpus (ARC) Related Work Related Work Object-centric Models for ARC Grids Object-centric Models for ARC Grids MDL-based Model Learning MDL-based Model Learning Evaluation Evaluation Conclusion and Perspectives, References & Supplementary Materials Conclusion and Perspectives, References & Supplementary Materials 2 Abstraction and Reasoning Corpus (ARC) ARC is a collection of tasks3 , where each task is made of training examples (3.3 on average) and test examples (1 in general). Each example is made of an input grid and an output grid. Each grid is a 2D array (with size up to 30x30) filled with integers coding for colors (10 distinct colors). For a given task, the size of grids can vary from one example to another, and between the input and the output. Each task is a machine learning problem, whose goal is to learn a model that can generate the output grid from the input grid, and so from a few training examples only. Prediction is successful only if the predicted output grid is strictly equal to the expected grid for all test examples, there is no partial success. However, three trials are allowed for each test example to compensate for potential ambiguities in the training examples. Figure 1 shows two ARC tasks (with the expected test output grid missing). The first is used as a running example in this paper. We now more formally define grids, examples, and tasks. ARC tasks have 3.3 training examples on average, and 1 or 2 test examples (most often 1). As illustrated by Figure 1, the different input grids of a task need not have the same size, nor use the same colors. The same applies to test grids. ARC is composed of 1000 tasks in total: 400 “training tasks”4 , 400 evaluation tasks, and 200 secret tasks for independent evaluation. Figure 1 shows two of the 400 training tasks. Developers should only look at the training tasks, not at the evaluation tasks. The latter should only be used to evaluate the broad generalization capability of the developed systems. This paper is available on Arxiv under CC 4.0 license. Arxiv Arxiv

The Definition of Abstraction and Reasoning Corpus (ARC): A Beginner's Lesson

Designed for developers familiar with Azure and generative AI, the guide walks you through the process of harnessing the power of the gpt turbo model for code generation. Introduction The Microsoft team has recently launched an challenge in which a developer can learn how to build Azure AI solutions and apps. Open AI Prerequisite Experience working with Azure and Azure portals. An understanding of generative AI. Experience in one high-level programming language like C# or Python Steps to Create Open AI Service on Azure with “Dall-E” model deployed. Day 1 — Azure Open AI Challenge If you would like to explore image generation, follow this link Day 2 — Azure Open AI Challenge: Image Generation Getting Started Considering Azure Open AI Service is running on the Azure portal and the gpt-turbo model is deployed successfully. Step 1: Create a console application To test image generation, create a console application in Visual Studio or Visual Studio Code. dotnet new console Step 2: Read the configuration Read the configuration from appsettings.json file // Build a config object and retrieve user settings.
    IConfiguration config = new ConfigurationBuilder()
        .AddJsonFile("appsettings.json")
        .Build();
    string? oaiEndpoint = config["AzureOAIEndpoint"];
    string? oaiKey = config["AzureOAIKey"];
    string? oaiDeploymentName = config["AzureOAIDeploymentName"]; Step 3: Add sample code Create a file under the console application project as follows: sample-code> function > function.cs namespace Function
    {
        class Program
        {
            int AbsoluteSquare(int num1, int num2)
            {
                int result = Math.Abs(num1 - num2);
                result *= result;
                return result;
            }
        }
    } Another file as sample-code > go-fish > go-fish.cs => Reference file Step 3: Prepare Console Menu The next step is to prepare a menu on the console application using digits. If the console message is “quit” the console application is exited. If the console input is 1 or 2, then the sample file function.cs is used If the console input is 3, then the sample file go-fish.cs is used Else it will return a console message saying invalid input do
    {
        Console.WriteLine("\n1: Add comments to my function\n" +
        "2: Write unit tests for my function\n" +
        "3: Fix my Go Fish game\n" +
        "\"quit\" to exit the program\n\n" +
        "Enter a number to select a task:");
    
        command = Console.ReadLine() ?? "";
    
        if (command == "quit")
        {
            Console.WriteLine("Exiting program...");
            break;
        }
    
        Console.WriteLine("\nEnter a prompt: ");
        string userPrompt = Console.ReadLine() ?? "";
        string codeFile = "";
    
        if (command == "1" || command == "2")
            codeFile = System.IO.File.ReadAllText($@"{AppDomain.CurrentDomain.BaseDirectory}sample-code\function\function.cs");
        else if (command == "3")
            codeFile = System.IO.File.ReadAllText($@"{AppDomain.CurrentDomain.BaseDirectory}sample-code\go-fish\go-fish.cs");
        else
        {
            Console.WriteLine("Invalid input. Please try again.");
            continue;
        }
    
        userPrompt += codeFile;
        await GetResponseFromOpenAI(userPrompt);
    } while (true); Step 4: Code generation from AI Please find below the method GetResponseFromOpenAI, which generates the code using gpt-turbo. Read the configuration values required, if not present don’t execute. Prepare the request for chat completion response. Finally, write the response back to result > app.txt file async Task GetResponseFromOpenAI(string prompt)
    {
        Console.WriteLine("\nCalling Azure OpenAI to generate code...\n\n");
    
        if (string.IsNullOrEmpty(oaiEndpoint) || string.IsNullOrEmpty(oaiKey) || string.IsNullOrEmpty(oaiDeploymentName))
        {
            Console.WriteLine("Please check your appsettings.json file for missing or incorrect values.");
            return;
        }
    
        // Configure the Azure OpenAI client
        OpenAIClient client = new OpenAIClient(new Uri(oaiEndpoint), new AzureKeyCredential(oaiKey));
    
        // Define chat prompts
        string systemPrompt = "You are a helpful AI assistant that helps programmers write code.";
        string userPrompt = prompt;
    
        // Format and send the request to the model
        var chatCompletionsOptions = new ChatCompletionsOptions()
        {
            Messages =
            {
                new ChatRequestSystemMessage(systemPrompt),
                new ChatRequestUserMessage(userPrompt)
            },
            Temperature = 0.7f,
            MaxTokens = 1000,
            DeploymentName = oaiDeploymentName
        };
    
        // Get response from Azure OpenAI
        Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
    
        ChatCompletions completions = response.Value;
        string completion = completions.Choices[0].Message.Content;
    
        // Write full response to console, if requested
        if (printFullResponse)
        {
            Console.WriteLine($"\nFull response: {JsonSerializer.Serialize(completions, new JsonSerializerOptions { WriteIndented = true })}\n\n");
        }
    
        // Write the file.
        System.IO.File.WriteAllText(@"result\app.txt", completion);
    
        // Write response to console
        Console.WriteLine($"\nResponse written to result/app.txt\n\n");
    } Test Case 1: Add comments to the code Choose option 1 Then add the following prompt to add comments to the code Add comments to the following function. Return only the commented code. Output Test Case 1 Refer to the sample on . function.cs file GitHub Please find below the convert function with the single line comments added as shown below. // This function calculates the absolute square of the difference between two numbers
    
    namespace Function
    {
        class Program
        {
            // Function to calculate the absolute square of the difference between two numbers
            int AbsoluteSquare(int num1, int num2)
            {
                // Calculate the absolute difference between the two numbers
                int result = Math.Abs(num1 - num2);
    
                // Square the result
                result *= result;
    
                // Return the absolute square of the difference between the two numbers
                return result;
            }
        }
    } Additionally, the user can suggest gpt model to add multi-line comments instead of single lines using the following prompt Add comments to the following function. Return only the commented code. — namespace Function
    {
        class Program
        {
            // This function calculates the absolute square of the difference between two integers.
            // Parameters:
            //   num1: the first integer
            //   num2: the second integer
            // Returns:
            //   The absolute square of the difference between num1 and num2
            int AbsoluteSquare(int num1, int num2)
            {
                int result = Math.Abs(num1 - num2);
                result *= result;
                return result;
            }
        }
    } Test Case 2: Add comments to the code Choose option 2 Then add the following prompt to add comments to the code Write four unit tests for the following function. — Output Test Case 2 Refer to the sample on . Please find below the test cases added function.cs file GitHub Sure! Here are four unit tests for the `AbsoluteSquare` function:
    
    1. Test case where `num1` is greater than `num2`:
    
    [Test]
    public void TestAbsoluteSquare_GreaterNum1_ReturnsSquaredDifference()
    {
        int num1 = 5;
        int num2 = 2;
        int expected = 9;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    }
    
    2. Test case where `num2` is greater than `num1`:
    
    [Test]
    public void TestAbsoluteSquare_GreaterNum2_ReturnsSquaredDifference()
    {
        int num1 = 2;
        int num2 = 5;
        int expected = 9;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    }
    
    3. Test case where `num1` and `num2` are the same:
    
    [Test]
    public void TestAbsoluteSquare_SameNumbers_ReturnsZero()
    {
        int num1 = 4;
        int num2 = 4;
        int expected = 0;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    }
    
    
    4. Test case where `num1` and `num2` are negative:
    
    [Test]
    public void TestAbsoluteSquare_NegativeNumbers_ReturnsSquaredDifference()
    {
        int num1 = -3;
        int num2 = -6;
        int expected = 9;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    } Test Case 3: Fix my Go Fish game Choose option 3 Then add the following prompt to add comments to the code Fix the code below for an app to play Go Fish with the user. Return only the corrected code. — Output Test Case 3 Refer to the sample on . go-fish.cs file GitHub Please find below the code that is fixed. using System;  
    using System.Collections.Generic;  
    using System.Linq;  
      
    namespace GoFish  
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                // Define the deck of cards  
                List<string> deck = new List<string> { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };  
                deck.AddRange(deck);  
                deck.AddRange(deck);  
                deck.AddRange(deck);  
      
                // Shuffle the deck  
                var rand = new Random();  
                deck = deck.OrderBy(x => rand.Next()).ToList();  
      
                // Deal the cards  
                List<string> playerHand = deck.Take(5).ToList();  
                List<string> computerHand = deck.Skip(5).Take(5).ToList();  
      
                // Define the initial score  
                int playerScore = 0;  
                int computerScore = 0;  
      
                // Define the main game loop  
                while (deck.Count > 0)  
                {  
                    // Print the player's hand  
                    Console.WriteLine("Your hand: " + string.Join(", ", playerHand));  
      
                    // Ask the player for a card  
                    Console.Write("Do you have any... ");  
                    string card = Console.ReadLine();  
      
                    // Check if the player has the card  
                    if (playerHand.Contains(card))  
                    {  
                        // Remove the card from the player's hand  
                        playerHand.Remove(card);  
      
                        // Add a point to the player's score  
                        playerScore += 1;  
      
                        // Print the player's score  
                        Console.WriteLine("You got a point!");  
                        Console.WriteLine("Your score: " + playerScore);  
                    }  
                    else  
                    {  
                        // Go fish!  
                        Console.WriteLine("Go fish!");  
      
                        // Draw a card from the deck  
                        string drawnCard = deck.First();  
                        deck.RemoveAt(0);  
      
                        // Add the card to the player's hand  
                        playerHand.Add(drawnCard);  
      
                        // Print the card that was drawn  
                        Console.WriteLine("You drew a " + drawnCard);  
                    }  
      
                    // Check if the player has won  
                    if (playerScore == 5)  
                    {  
                        Console.WriteLine("You win!");  
                        break;  
                    }  
      
                    // Computer's turn  
                    string computerCard = computerHand[rand.Next(computerHand.Count)];  
                    Console.WriteLine("Do you have any " + computerCard + "?");  
                    if (playerHand.Contains(computerCard))  
                    {  
                        // Remove the card from the player's hand  
                        playerHand.Remove(computerCard);  
      
                        // Add a point to the computer's score  
                        computerScore += 1;  
      
                        // Print the computer's score  
                        Console.WriteLine("The computer got a point!");  
                        Console.WriteLine("Computer score: " + computerScore);  
                    }  
                    else  
                    {  
                        // Go fish!  
                        Console.WriteLine("The computer goes fishing!");  
      
                        // Draw a card from the deck  
                        string drawnCard = deck.First();  
                        deck.RemoveAt(0);  
      
                        // Add the card to the computer's hand  
                        computerHand.Add(drawnCard);  
      
                        // Print the card that was drawn  
                        Console.WriteLine("The computer drew a " + drawnCard);  
                    }  
      
                    // Check if the computer has won  
                    if (computerScore == 5)  
                    {  
                        Console.WriteLine("The computer wins!");  
                        break;  
                    }  
                }  
            }  
        }  
    } Finally, if you type quit, the console application will be terminated. Complete code on GitHub Make sure to give it a star on GitHub and provide feedback on how to improve the tool further..!! ssukhpinder/AzureOpenAI C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

Taking the Azure Open AI Challenge, Day 3: Mastering Code Generation

This paper is available on arxiv under CC 4.0 license. Authors: (1) Ali Ghanbari, Dept. of Computer Science, Iowa State University; (2) Deepak-George Thomas, Dept. of Computer Science, Iowa State University; (3) Muhammad Arbab Arshad, Dept. of Computer Science, Iowa State University; (4) Hridesh Rajan, Dept. of Computer Science, Iowa State University. Table of Links Abstract & Introduction Background Motivating Example Proposed Approach Supported DNN Bugs Evaluation Threats to Validity Related Work Conclusion, Acknowledgments & References IV. PROPOSED APPROACH Our technique deepmufl comprises four components: (1) mutation generator, (2) test case splitter, (3) mutation executor/tester, and (4) suspiciousness calculator. Figure 2 depicts these components as processes, numbered accordingly, taking inputs and producing outputs. Mutation generator (marked ⃝1 in Figure 2), applies 79 mutators on all the layers of the input buggy DNN, so as to generate a pool of mutants, i.e., variants of the original, buggy DNN model with small perturbations, e.g., replacing activation function of a layer. Test case splitter (marked ⃝2 in the figure), applies the original buggy DNN on a given set of test data points, i.e., test cases (or input values) paired with their expected output values, so as to partition the set into two subset, namely passing test cases and failing test cases. Passing test cases are referred to as those input values for which the expected output matches that of produced by the original model, whereas failing test cases are referred to as those input values for which the expected output does not match that of produced by the model. This component also stores the output of the original model on each of the test cases. Next, mutation executor (which is also called mutation tester, marked ⃝3 in the figure) applies the generated mutants on each of the passing and failing test cases and the results are compared to that of the original model recorded in the previous step. This amounts to a mutation execution matrix that is used to calculate suspiciousness values for each layer in the model (marked ⃝4 in the figure). The user may instruct deepmufl to use a specific fault localization formula, e.g., MUSE or Metallaxis with SBI or Ochiai, for calculating suspiciousness values. The layers are then ranked based on the calculated suspiciousness values for user inspection. The ranked list is accompanied with the information about the mutations conducted on each layer to facilitate debugging. A. Mutation Generator Mutation generator component receives the original, buggy DNN model and generates as many variants of the model, i.e., mutants, as possible, by systematically mutating every elements of the input model. This component implements 79 mutators. Mutators can be viewed as transformation operators that when applied to a given element, e.g., a neuron or a layer, in the model, returns a new variants of the model with that particular element mutated. Table 2 lists all the mutators implemented in deepmufl, the types of model elements on which they can operate, and the way each mutator affects the target element. These mutators are inspired by the ones implemented in the existing mutation analysis systems, e.g., [27], [28], [29], [49], [50], [51], [52], [53], to name a few. Ma et al. [29], and Hu et al. [28], define so-called model-level mutators that also operate on pre-trained models. Direct reuse of all of their mutators was not possible, as those mutators depend on random values which would introduce a source of nondeterminism in deepmufl: mutating the same model element with random values, e.g., Gaussian fuzzing, as in [29], would yield a different mutant each time, making deepmufl to produce different outputs on each run for the same model. In general, as far as MBFL is concerned, using variable values (whether it is deteministic or not), instead of the current hard-coded ones, for mutation of weights would not bring about any benefit, as the goal here is to break the model in some way and observe its impact on originally failing and passing test cases. We argue that not all model bugs could be emulated using mutators at the level of pre-trained models, e.g., missing batch normalization, but the mutators listed in Table 2 are sufficient for emulating a subset of such bugs, e.g., wrong activation function or missing/redundant layer. Please see §V for a more detailed discussion on supported bugs. Mutation generation in deepmufl is done directly on the trained model and there is no need for retraining the model. This makes deepmufl quite fast and perhaps more attractive from a practical point of view. However, this comes with a risk of not being traceable, i.e., a mutation on pre-trained .h5 model does not directly correspond to a line of source code for the user to inspect. In the Keras programs that we studied, this limitation was mitigated by the fact that the models with Sequential architecture were implemented using a wellunderstood structure and mapping layer numbers/identifiers in deepmufl’s reports to source code was trivial. In a future work, with the help of simple auto-generated annotations, e.g., for lexical scoping of the code snippet for model declaration, we will extend deepmufl to automatically map layer numbers/identifiers in its reports to actual lines of source code. Humbatova et al. [27] argue about the importance of mutators emulating real DNN faults. We acknowledge that mutators emulating real faults would help generating more informative reports that would also give hints on how to fix the program. However, unlike mutation analysis, the main objective of an MBFL technique is to assign suspiciousness values to the program elements which can, in theory, be done using any kind of mutator, whether or not it makes sense from the standpoint of a developer. It is worth noting that the alternative design decision of using DeepCrime [27] as a mutation generation engine for deepmufl would result in finding more bugs than the current version of deepmufl, e.g., bugs related to training hyper-parameters or training dataset, but such a design is expected to be impacted by the nondeterminacy inherent in training process and, given the fact that we do not employ any training data selection, would be significantly slower due to numerous re-training. Nevertheless, finding more bugs would be an incentive for exploring this alternative as a future work. B. Test Case Splitter Before we introduce this component, we need to clarify certain terminology. .** Definition 1 A data point in a testing dataset for a DNN model is defined to be a pair of the form (I, O), where I ∈ R m and O ∈ R n, with m and n being positive integers. In this paper I is called test case, test input, or input, while O is called expected output or ground-truth value. Given a test dataset, test case splitter component applies the original model on each of the test cases for the data points and checks if the model output matches to the expected output. If the two outputs match, then the corresponding test case will be marked as passing, otherwise it will be marked as failing. This component also records the output produced by the original model to be used during impact analysis, described below. C. Mutation Executor (Mutation Tester) We start describing this component with a definition. Definition 2. A mutation execution matrix E is a k×l matrix, where k is the number of generated mutants, while l is the number of test cases. Each element Ei,j in the matrix is a member of the set {✓, ✗, ❍}, wherein ✓ indicates that the i th mutant impacts j th test case, whereas ✗ indicates that the mutant does not affect the test case. ❍ denotes a nonviable mutant, i.e., a mutant that fails when loading or applying it on a test case. Such mutants might be generated, e.g., due to creating a shape error [32] after the mutation. Mutation executor component construct mutation execution matrix by applying each of the generated mutants (see §IV-A) on the failing and passing test cases to determine which of the test cases are impacted by which mutants. The impact of mutation on test cases is measured using two types of impacts, i.e., type 1 impact and type 2 impact, defined below. Definition 3. Given a DNN model M, its mutated version M′ , and a data point (I, O), we define the two types of impacts: • Type 1: Mutant M′ impacts the test case I if M(I) = O but M′ (I) ̸= O, or M(I) ̸= O but M′ (I) = O. In other words, type 1 impact tracks pass to fail and fail to pass test cases, a la MUSE [17]. ` • Type 2: Mutant M′ impacts the test case I if M(I) ̸= M′ (I). In this definition, M(I) or M′ (I) denotes the operation of applying model M or M′ on the test case I. It is worth noting that checking for equality of two values can be tricky for regression models, as those models approximate the expected values. To work around this problem, deepmufl compares values obtained from regression models using a user-defined delta threshold, i.e., the values are deemed equal if their absolute difference is no more than a threshold. By default, deepmufl uses a threshold of 0.001. This is the approach adopted by well-known testing frameworks for comparing floating-point values [54], [55]. Also, whether deepmufl uses type 1 or type 2 impact is a user preference and is determined alongside the threshold. D. Suspiciousness Value Calculator Armed with the above definitions, we can now give concrete definitions for the terms used in Eq. 1, 2, and 3, specialized to DNNs. • Given a model element, i.e., neuron or a layer, e, M(e) is defined to be the set of all mutants generated by mutating e. These sets are produced by mutation generator process. • Assuming that m is a mutant on the element e, Tf (m, e) (or Tp(m, e)) is defined as the set of failing (or passing) test cases that are impacted in type 1 or type 2 fashion by m. More concretely, Tp(m, e) = {t | Em,t = ✓ ∧ t is passing}, similarly Tf (m, e) = {t | Em,t = ✓ ∧ t is failing}. These two sets are defined using a quite similar notation; the readers are encouraged to review Definitions 2 and 3 to avoid confusion. • Tf (or Tp) is the set of originally failing (or passing) test cases. These sets are constructed by test case splitter. • F ⇝ P (or P ⇝ F), for a model element e, is defined as the set of originally failing (or passing) test cases that turned into passing (or failing) as a result of some mutation on e. More concretely, assuming the execution matrix E is constructed using type 1 impact, F ⇝ P is defined as {t | t is failing ∧ ∃m ∈ M(e) · Em,t = ✓}. Similarly, P ⇝ F is defined as {t | t is passing ∧ ∃m ∈ M(e)·Em,t = ✓}. In other words, these sets track all the failing/passing test cases that are type 1 impacted by some mutant of a given element. These two sets are defined using a quite similar notation; the readers are encouraged to review Definitions 2 and 3 to avoid confusion. Having specialized definitions for the terms used in the fault localization formulas described earlier, we are now able to calculate suspiciousness values for the elements in a DNN model. Guided by the user preferences, deepmufl calculates all the values for |Tf (m, e)|, etc., and plugs into the specified formula to calculate suspiciousness values for the elements. It is worth noting that if all the mutants generated for a given element are nonviable, MUSE formula (Eq. 3) and all the variants of Metallaxis (e.g., Eq. 1), by definition, will return 0 as the suspiciousness value for the element. Nonviable mutants do not contribute toward localizing the bug, therefore they are considered overhead to the fault localization process. Fortunately, based on our observations in our dataset of buggy DNNs, nonviable mutants are rare. Equivalent mutants are another source of overhead for deepmufl. Currently, we do not have any means of detecting equivalent mutants, but we argue that these mutants do not impact MBFL results, as they are equivalent to the original model and do not impact any passing or failing test cases.

Mutation-based Fault Localization of Deep Neural Networks: Proposed Approach

The market offers a wide range of solution providers to choose from. The Best Identity Verification Software category on any listing platform includes over 200 products. Add to it all sorts of hardware devices, and you’ll get the impression that the market is over-saturated, and there are plenty of go-to solutions for handling ID documents and Biometric verification for any business use case. Identity Verification Below is a 9-step guide that will empower you with insights on how to choose the best Identity Verification (IDV) software provider effectively, guiding your selection towards ones that excel in delivering precision, security, and the utmost trustworthiness in the field of identity verification. Step 1: Make sure that document capture is fully automated If you ask any forensic expert how to verify ID documents reliably, they will likely give you the following answer: first of all, make sure you have a physical document at hand. The reality, however, is often far from such ideals. In the face of digital transformation, the capture process largely determines the check’s credibility. At the capture stage, an identity verification solution should cope with two things: recognize the submitted document and assess its quality. The thing is that software solutions use the capabilities of the user’s device, and rely on the user’s accuracy in taking photos. A bad camera, poor lighting, glares, or a skewed image make it difficult to read the information. This may lead to either errors or asking users to re-take photos over and over again until they meet the quality requirements. The best solutions can assess an image's quality and fine-tune it if necessary: adjust brightness or contrast, remove glares, or deskew the photo if it was shot at an angle. As for document type recognition, it’s mostly a matter of Unfortunately, many identity verification solutions still add two extra steps in the user journey: “choose your document type” and “choose your country.” UX. You can avoid making your users do extra clicks and typing by choosing a solution that identifies the document type and its origin country. As simple as it sounds, such capabilities require the vendor to invest a lot of time, money, and effort into creating a comprehensive document template database. For now, let’s just make a mental note that, ideally, your identity verification solution should do most of the work automatically. Questions to ask a vendor: Does your solution identify the document type automatically? Does it assess the document image quality? What are the criteria? Can it enhance the image’s quality to improve the data's readability? Step 2: Test-drive document checks Identity verification solutions must comply with ICAO and BSI guidelines for checking international documents, visas, etc. For domestic ID documents, though, there may be their own variants of execution of security elements of protection that require specific checks. Ideally, an identity verification solution should offer a check for each aspect: both standardized international features and local characteristics. The denser the coverage with checks, the more credible the conclusion about the authenticity and validity of the document. You can judge a vendor to provide first-class performance when their solution performs a long list of checks, plus runs massive cross-checks comparing the data from different elements to make sure they match. Document checks to ask for: Automatic document type identification Visual inspection zone verification MRZ validation Barcode type and format reading and validation Document liveness check (includes checks of holograms and screenshot detection) RFID chip detection and reading Cross-checks of the data fetched from different elements Step 3: Ensure that NFC-based RFID chip verification is in place A radio-frequency identification—or simply —chip is a tiny device that modern electronic ID documents contain. RFID chips store document holders’ data. The ICAO (International Civil Aviation Organization) strictly regulates the exact list of the data encoded in the chip. RFID Usually, reading this information entails using special passport readers or NFC technology built into mobile phones. You should be especially careful if it’s the latter. In the case of a remote process, there’s a risk that fraudsters can intercept and modify verification results. That’s why a good vendor needs to practice a zero-trust-to-mobile approach. In practice, the data needs to be re-verified to ensure the chip is not cloned or its data manipulated. Here’s an example of how Regula tackles this issue. RFID sessions can be re-verified on the server side in addition to the checks conducted on mobiles. Thanks to this, the data of the check is impossible to compromise. All this is done strictly on-premises: the results of the verification session are stored on a customer’s server, so it’s possible to get back to them afterward. This approach is considered the most reliable and secure way to verify a document with an NFC chip. Questions to ask a vendor: Does your identity verification solution read and verify an RFID chip? Can it read the information encoded in the chip? Do you apply a zero-trust-to-mobile approach? If so, how exactly does it work in your solution? Step 4: Explore capabilities for Biometric checks Validating the ID document is just a part of identity verification. Another part is ensuring that the person submitting it is the legitimate holder. That’s done with the help of biometric checks. Biometrics is a broad term that may imply a wide range of checks: face, fingerprints, voice, or even iris recognition. Most of them are overkill for regular business’ digital onboarding, but state authorities can require them, for example, when you apply for a visa. The most common way to run a biometric check for business is by using face biometrics. The process is simple: the user takes a selfie, and then the technology matches that photo with the photos in the submitted ID document (e.g., in the visual inspection zone and the RFID chip), and flags if there’s anything wrong. The essential feature of a proper face recognition module is liveness detection. That means you need not only to determine that it’s the same person in the photographs but also to make sure that the selfie is real. Sometimes attackers try to pass off an edited photo as a real selfie. Sometimes, they might use various masks and even deepfake technology. A good identity verification solution should be able to detect such issues. There are two types of liveness verification: passive and active. A passive liveness check implies the use of a static selfie, while active liveness requires the user to perform a series of simple movements: rotating the head, moving closer or further away, etc. Questions to ask a vendor: Do you perform biometric verification? What components does it include (face detection, face matching, face search, age verification, etc.)? Do you provide active or passive liveness checks? What PAD (Presentation Attack Detection) do you protect from? Step 5: Investigate the database of supported documents Cutting-edge technologies on their own aren’t enough for thorough identity verification. The most reliable IDV requires a deep knowledge of identity documents. This usually comes in the form of a document template database containing detailed information for every document: layout, fields, data recording methods, security elements, and more. Gathering such a collection requires tremendous resources and a solid background in document forensics. Ideally, your vendor should have seasoned forensic experts on their team to guarantee the comprehensiveness of templates and competent maintenance of the database. The importance of this cannot be overstated. If the vendor has thoroughly examined thousands of document types, its software solutions can easily distinguish one from another, fully read them, and extract the required data, therefore effectively verifying them as a result. The database needs to be extensive, as even within one country, there can be multiple versions of a document based on the date of issuance. Considering the frequent renewal and re-issuance of identity documents, the database should be regularly updated too. Cooperation with international organizations and security agencies is also a point in favor of the provider. Established relationships help them regularly expand the database with new document types and share the best practices in detecting document fraud. Questions to ask a vendor: How long have you been operating in the identity verification industry? Are there experts on your team with hands-on experience as forensic analysts? Do you have a document template database? How many items does it include? If there is no document in the database, how long does it take to add? Is it proprietary or bought from third parties? Step 6: Evaluate the time to value Reliability and completeness of checks are all good, but they won’t be of help if the integration process takes ages and blows up your budget. The pressure comes from multiple sides. On one side, there are regulators whose requirements are better met sooner than later. Then, there’s also your product and workflows, which will likely demand some customization from the identity verification solution. Add to it a learning curve that, for some solutions, can be rather steep, and lengthy. Questions to ask a vendor: Is it possible to build your solution into a web app? How fast will we be able to get up and running? What does the integration process look like? What customization options does your solution offer? Are they available out of the box, or will they require additional configuration/costs? Step 7: Check out the compliance of the workflows Regardless of the industry, safeguarding customer data is of the utmost importance. Therefore, it’s crucial to find out how your identity verification provider addresses the matter. When it comes to working with customers’ personally identifiable information (PII) during identity verification, there are two primary approaches: where vendors handle the storage and processing of customer data on their own infrastructure. A Software-as-a-Service (SaaS) scenario, where you store and process your customers' PII within your own secured perimeter. An On-premises approach, While the SaaS use case can save you time and the expenses associated with securing the data on your own, it’s even more critical to thoroughly examine the vendor’s procedures for customer data security and protection. Data breaches aren’t uncommon. An on-premises option places a higher emphasis on data privacy and security. Since no third parties have access to PII, it reduces the risk of breaches. However, extra protection comes at a price. The maintenance of infrastructure and reliability for following security policies is on you, so you’ll need to budget resources for engineering and security training for employees. Questions to ask a vendor: What type of solution do you offer: cloud or on-prem? Do you collect and store the personal data of end users? If it’s cloud… What certifications does your service have? (e.g., SOC1 type 2, HIPAA, etc.) Where can I read your security policy? What’s your service availability time? Step 8: Try to contact tech support Salespeople might be responsive before making the sale, but a company’s true colors show when a customer faces difficulties or has a request. If a vendor can provide prompt and professional technical support, it saves you a lot of time, effort, and headaches. Ideally, it’s good to have more than one way to contact support: by phone, email, live chat, or messengers. In most companies, additional communication channels come with the premium support option. Such support may include a dedicated manager, and the ability to communicate with the vendor’s team in real-time, 24/7. If this option is not available, pay attention to the response time SLA. This is the time in which the vendor commits to respond to a client’s issue. It’s usually defined by the support policy. As for cases when a client needs off-hours assistance, the vendor’s website should provide all essential instructions, guides, and FAQs. Comprehensive documentation should answer 90% of the questions, so pay attention to how thoroughly it is made, if it includes demo examples, how often it is updated, and if it’s localized to your language. Questions to ask a vendor: What’s your response time for support requests? Do you have a premium support option? Is support documentation comprehensive and easy to navigate? Step 9: Find customer references If you made it through the steps above, you can confidently trust the results. Still, it’s always a good idea to look for additional social proof from companies that have already succeeded in what you’re trying to achieve. Here, we advise you to conduct your own research and find as many reviews about the vendor as possible. The first go-to source of information is the case study section on the vendor’s website. There, you can look for stories from customers from your niche and find relevant use cases. For example, if you’re a crypto platform on a quest to deploy KYC, then KYC-related cases from banks will also give you valuable insights. Also, pay attention to who a vendor’s existing customers are. The presence of well-known names is a good sign. If the vendor has state-level organizations and security agencies, such as border controls, among their customers, it’s also great, because they have the strictest requirements for identity verification. Also, you may want to research what the media say about different vendors. Consider exploring not only so-called tier-one resources, such as The New York Times or Business Insider but focus more on industry-specific publications that specialize in covering identity verification and cybersecurity. This approach will broaden your research and provide a more comprehensive understanding of different vendors' reputations. Among such media outlets are: Biometric Update, Help Net Security, Infosecurity Magazine, Source Security, Identity Week, Find Biometrics, and others. Try to find out: Are there any references available in open sources from customers in my industry? Can the vendor provide those references on request? Are there relevant use cases in the vendors’ customer success stories? Are there any mentions of the vendor in the industry and/or tier-one media? In conclusion, this 9-step guide empowers you to choose Identity Verification software that aligns with your specific needs while excelling in precision, security, and trustworthiness, ensuring your data and operations are in safe hands. With the right software, you can confidently navigate the evolving landscape of identity verification for a secure and seamless future. If you’re struggling with finding the right solution for your business use case – feel free to get in touch. Also published . here

How to Choose the Best Identity Verification Software

In programming, a lot of the challenge is related to organizing data in a structure that makes sense and which helps to solve the problems and facilitates understanding of the . In this article, I’ll show you what tools you have at your disposal and how to use them. code Building blocks To simplify our discussion, let’s focus on what we have available in JSON—the data format that was created based on how data can be . In this way, we don’t need to think about the performance implications of different data structures—we only focus on the usefulness of the data model. hard-coded in JavaScript Primitive values These are the most basic value types we can have in our program. In JSON, those values are: boolean—a true or false value, a number—a floating-point value, string—a sequence of letters, and —a missing value, which is still useful for expressing certain states. null Already, with those basic types, we have the possibility of addressing the same thing in different ways. For example, for customer type, you could use some of the following: —which could accept any other string value, both valid or invalid ones const customerType = “retail”; —a more rigid approach: its two options are obvious and clear, but it has no way of allowing more possibilities const isRetail = true; —can be expanded but requires documentation for understanding what each number means const customerType = 2 Anything you decide will impact how easy it will be to change code later on. As you are picking the value type for your variable, it’s good practice to try to think about possible changes and pick a type that fits well for both current and future needs. Arrays Arrays are ordered lists of values. The JavaScript arrays can mix any type of values, for example: const someArray = [ 1, 2, “test”, [“another”, “array]]; Although it is a valid array, mixed types arrays are confusing to work with. It’s way easier to stick to keeping the same types of values in an array. An important feature of arrays is that they are ordered. This makes them a great match for places where you care about similar data points and where the order is meaningful. For example: Products in cart—you definitely want to display items from a cart in the same order and students in a class—each one of them has their list number. Arrays work well when you access many values in sequence. It’s less useful when you want to find whether a given value is in an array. When I find myself often using to see if an array has some object I’m looking for, I take it as a potential sign that I should reorganize the data structure. includes() Objects The object is a structure that consists of a set of key–value pairs. The structure is unordered, so it makes it a suitable choice for many places that don’t fit the array. Each value on an object can be understood independently of all the rest, so you can mix different types of values without worry. Example of an object: const user = {
  login: “lorem.ipsum”,
  email: “sin@dolor.com”,
  age: 24,
} Objects are a good match for collections of named, unordered properties. For example, a set of permissions: const hasAccessTo = {
  blog: true,
  blogAdmin: true,
  userAdmin: false
} Built-in objects JavaScript provides many object types that you can use on the code side to keep your values in a more suitable form—and with methods that make them more usable. For example: —for date-time values, Date —for unordered collections of unnamed values that don’t repeat and Set —a non-string identifier that will not collide with other values. Symbol Those types are very useful, but in communication that goes through a web API that uses JSON to represent data, they all will be serialized to the value types described above. In my daily job, where I program business applications, the only types that I use regularly are dates. Pick the appropriate structure The way we organize data impacts what can be easily done in our code. Let’s take a look at the permission example from above: const hasAccessTo = {
  blog: true,
  …
} This value can be used easily in conditional cases such as: . if (hasAccessTo.blog) The same requirement for a permission list could be met with another data structure: const permissions: [{
    resource: “blog”,
    access: true,
  },{
    resource: “blogAdmin”,
    access: true,
  },{
    resource: “userAdmin”,
    access: false,
  },
] The same condition from above would need to be replaced by: const blogPermission = permissions.find(x => x.resource === ”blog”);

if (blogPermissions?.value) {
… This is much harder to read, and it’s easier to write code that will throw errors in some specific cases. By using arrays, the only thing we “gain” is the order of permissions, which shouldn’t matter. Create a draft There are plenty of things to consider as we organize data in our codebase, and calls can get complicated pretty quickly. To avoid rewriting code, it makes sense to create some form of draft for the structures. In my case, I often describe them with the names I plan to use in the tickets I’m going to work on. Often, when you see your structure design written down, you’ll notice some issues with it. Keep on improving The data structure for your code will never be finished—it should keep evolving with your application. Changing names they appear in many places in code and in databases be painful. However, it is necessary because otherwise, the mismatch between names and their current understanding will only grow as things change over time. This is a common source of code debt that often slowly piles up until it makes working with the code an unpleasant and unproductive experience. after will Also published . here

Tips For Writing Maintainable Code: Data Models

Test Faster, Test Smarter: Unlocking Selenium's Full Potential In today's fast-paced software development landscape, speed is of the essence. Testing teams strive to deliver high-quality software at a rapid pace, and plays a crucial role in achieving that goal. the execution time of UI test suites Selenium, the widely adopted UI testing framework, provides powerful capabilities for automating browser actions and validating web applications. However, is essential to ensure efficient testing processes and timely feedback. optimizing the execution time of Selenium test cases Explore five key strategies for accelerating Selenium test execution, along with the integration of Launchable's intelligent test optimization tools to further enhance speed and efficiency. 1. Efficient Selenium Locator Strategies Selenium Locators identify the correct UI element on a page, making it possible to create successful automation scripts. Optimizing your locator performance significantly reduces test execution time. Consider the following strategies: Utilize CSS selectors instead of XPath, as CSS selectors are generally faster and more efficient. driver.find_element(By.CSS_SELECTOR, "input#username") Employ unique and stable locators, such as IDs, names, or CSS classes, to ensure consistent test case execution. driver.find_element(By.ID, "username") Avoid excessive nesting of locators, as it can lead to slower element identification. driver.find_element(By.CSS_SELECTOR, "div.container input#username") For example, let's say you're automating a login functionality. Instead of using a complex XPath expression to locate the username input field, you can use a unique CSS selector, such as , resulting in faster test execution. input#username` 2. Test Case Prioritization and Parallel Execution To maximize test execution speed, it's crucial to prioritize test cases based on their business impact and implement parallel execution. Consider the following techniques: Identify high-impact test cases that cover critical functionality and prioritize their execution. Implement parallel execution using frameworks like TestNG or JUnit to execute multiple test cases concurrently. If you have a test suite containing multiple independent test cases, , reducing overall execution time. parallel execution can allow you to execute them simultaneously Get faster feedback without spending more on running parallel tests Launchable leverages AI to , generating dynamic test subsets. This approach enables teams to identify issues earlier while simultaneously minimizing compute costs. by adopting dynamic parallelization. predict which tests may fail 3. Make Your Selenium Testing Data-Driven Data-driven testing uses your test data to make your test execution more efficient and allows you to validate application behavior without running every test every time. Consider the following practices: Implement data-driven testing using Selenium and related frameworks, such as TestNG's data provider or JUnit's parameterized tests. Manage test data efficiently by using external data sources, such as CSV or Excel files. Make by leveraging Predictive Test Selection to optimize tests based on historical data patterns. Launchable builds a machine learning model based on your git data to get deep insights into how your tests run and how efficient they are. Selenium truly data-driven Then, it identifies what tests you should run, recommending the tests that directly test what was changed, . saving you time and speeding up your releases 4. Selenium Test Suite Optimization Optimizing the structure and content of your Selenium test suite can significantly reduce execution time. Consider the following optimization techniques: Identify and remove redundant test cases that cover similar scenarios. Reduce setup and teardown time by utilizing test fixtures and leveraging browser session reuse. Isolate and parallelize independent test cases to execute them concurrently, further speeding up the test suite execution. If your test suite includes multiple tests for user authentication, consider consolidating them into a single test case with parameterized inputs. To fully optimize your Selenium test suite, you need insights into the health of your tests and trends over time. like test runtime is crucial for improving development cycles, enabling faster feedback loops, and better test maintainability. Test runtime measurement brings various advantages, such as optimizing parallelization, managing resource allocation, prioritizing tests, and facilitating continuous improvement in your CI/CD pipelines. Measuring critical test health metrics Launchable's , enabling you to identify and optimize the test suite execution for maximum efficiency. Launchable provides automated tracking of test runtime, giving you in-depth visibility into the health of your test suite. This includes the ability to identify flaky tests, track the duration of test sessions, optimize the frequency of test sessions, and analyze the ratio of test session failures. Test Suite Insights provides valuable insights into test suite health KPIs 5. Selenium Test Environment Optimization Optimizing the test environment configuration contributes to faster test execution by making your environment run as smoothly as it possibly can. Consider the following strategies: Use lightweight browsers or headless modes, such as Headless Chrome or Firefox, to reduce resource consumption and improve performance. Using a headless browser eliminates the need to open a physical browser window, saving system resources and reducing overall execution time. from selenium.webdriver.chrome.options import Options

options = Options()

options.add_argument("--headless")

driver = webdriver.Chrome(options=options) Leverage cloud-based testing platforms, such as Selenium Grid or Sauce Labs, to distribute tests across multiple machines and browsers, increasing parallel execution capabilities. Ensure proper resource allocation and management, including CPU, memory, and network, to avoid performance bottlenecks. Reduce the need for context switching and streamline your test notifications where your developers are already working with Slack Test Notifications. Eliminate the need to hunt through inboxes or check in your CI; Launchable's and failures in the test environment, enabling swift action without disturbing your workday. personalized Slack Test Notifications provide real-time alerts about test execution performance Takeaways Optimizing Selenium test execution is paramount for efficient testing processes and timely feedback. By implementing these five strategies and , UI testing can significantly accelerate test execution, reduce development cycles, and deliver high-quality software with confidence. Achieve faster test execution times, optimize your testing workflow, and ensure high-quality releases in a time-efficient manner. integrating Launchable Also published . here

2TEST

2test.io

-- employees

Since n.d.

COMPANY RANKING

2TEST

EVERGREEN INDEX #1538

2TEST WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

2TEST

2test.io

-- employees

Since n.d.

COMPANY RANKING

2TEST

EVERGREEN INDEX #1538

RELATED COMPANIESRANK

STORIES ABOUT 2TEST

2TEST WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!