How Transformers work in computer vision

 Transformers, originally introduced in the field of natural language processing (NLP), have also proven to be highly effective in computer vision tasks. Here's an overview of how Transformers work in computer vision:

1. Input representation: In computer vision, the input to a Transformer model is an image. To process the image, it is divided into a grid of smaller regions called patches. Each patch is then flattened into a vector representation.

2. Positional encoding: Since Transformers do not have inherent positional information, positional encoding is added to the input patches. Positional encoding allows the model to understand the relative spatial relationships between different patches.

3. Encoder-decoder architecture: Transformers in computer vision often employ an encoder-decoder architecture. The encoder processes the input image patches, while the decoder generates the final output, such as image classification or object detection.

4. Self-attention mechanism: The core component of Transformers is the self-attention mechanism. Self-attention allows the model to attend to different parts of the input image when making predictions. It captures dependencies between different patches, enabling the model to consider global context during processing.

5. Multi-head attention: Transformers employ multi-head attention, which means that multiple sets of self-attention mechanisms operate in parallel. Each head can focus on different aspects of the input image, allowing the model to capture diverse information and learn different representations.

6. Feed-forward neural networks: Transformers also include feed-forward neural networks within each self-attention layer. These networks help transform and refine the representations learned through self-attention, enhancing the model's ability to capture complex patterns.

7. Training and optimization: Transformers are typically trained using large-scale labeled datasets through methods like supervised learning. Optimization techniques such as backpropagation and gradient descent are used to update the model's parameters and minimize the loss function.

8. Transfer learning: Pretraining on large datasets, such as ImageNet, followed by fine-tuning on task-specific datasets, is a common practice in computer vision with Transformers. This transfer learning approach helps leverage the learned representations from large-scale datasets and adapt them to specific vision tasks.

By leveraging the self-attention mechanism and the ability to capture long-range dependencies, Transformers have demonstrated significant improvements in various computer vision tasks, including image classification, object detection, image segmentation, and image generation.

AI-Generated Video Recommendations for Items in User's Cart with Personalized Discount Coupons

Description: The idea focuses on leveraging AI technology to create personalized video recommendations for items in a user's cart that have not been purchased yet. The system generates a video showcasing the benefits and features of these items, accompanied by a script, and provides the user with a personal discount coupon to encourage the purchase.

Implementation:

1. Cart Analysis: The system analyzes the user's shopping cart, identifying the items that have been added but not yet purchased.

2. AI Recommendation Engine: An AI-powered recommendation engine examines the user's cart items, taking into account factors such as their preferences, browsing history, and related products. It generates recommendations for complementary items that align with the user's interests.

3. Video Generation: Using the recommended items, the AI system generates a video with a script that highlights the features, benefits, and potential use cases of each product. The video may incorporate visuals, animations, and text overlays to enhance engagement.

4. Personalized Discount Coupons: Alongside the video, the user receives a personalized discount coupon for the items in their cart. The coupon could provide a special discount, exclusive offer, or additional incentives to motivate the user to complete the purchase.

5. Delivery Channels: The video and discount coupon can be delivered to the user through various channels such as email, SMS, or in-app notifications. Additionally, the user may have the option to access the video and coupon directly through their account or shopping app.

Benefits:

1. Increased Conversion Rates: By showcasing personalized video recommendations and providing discounts for items already in the user's cart, the system aims to increase the likelihood of completing the purchase.

2. Enhanced User Experience: The personalized video content offers a visually engaging and informative experience, enabling users to make more informed decisions about their potential purchases.

3. Cost Savings for Users: The provision of personalized discount coupons incentivizes users to take advantage of exclusive offers, saving them money on their intended purchases.

4. Reminder and Re-Engagement: Sending videos and discount coupons serves as a gentle reminder to users about the items in their cart, increasing the chances of re-engagement and conversion.

Conclusion:

The implementation of AI-generated video recommendations for items in a user's cart, accompanied by personalized discount coupons, provides a targeted and persuasive approach to encourage users to complete their intended purchases. By leveraging AI technology and delivering engaging content, this idea aims to enhance the user experience, boost conversion rates, and ultimately drive sales for the business.

AI-Powered Personalized Video Try-On Experience

 

 

Description: The idea involves utilizing an AI model to generate a personalized video try-on experience for users. The AI system would take the dress items added to the user's cart and create a video representation of the user wearing those dresses. This immersive and realistic video try-on experience aims to assist users in making informed purchase decisions and enhancing their shopping experience.

 

Implementation:

1. Dress Selection: The system analyzes the dress items added to the user's cart, considering factors such as style, color, size, and other preferences.

2. Virtual Dress Try-On: Using computer vision and image processing techniques, the AI model overlays the selected dresses onto a video representation of the user. The AI model ensures an accurate fit and realistic visualization, accounting for body shape, size, and movements.

3. Personalized Video Generation: The AI model generates a personalized video with the user's virtual representation wearing the selected dresses. The video showcases the dresses from various angles, allowing the user to visualize how the dresses would look on them.

4. Customization and Interaction: The system may provide options for users to customize aspects such as dress length, sleeve style, or accessories. Additionally, users can interact with the video, such as pausing, zooming, or rotating the virtual representation to examine the dress details.

5. Delivery and Feedback: The personalized video is delivered to the user via email, SMS, or in-app notification. Users can provide feedback, rate their virtual try-on experience, and share the video with friends and social media networks.

 

Benefits:

 

1. Visualized Purchase Decision: The personalized video try-on experience allows users to see how the dress looks on them before making a purchase, reducing uncertainty and increasing confidence in their buying decision.

2. Improved User Engagement: The immersive and interactive nature of the video try-on experience enhances user engagement, leading to a more enjoyable and satisfying shopping process.

3. Cost and Time Savings: Users can avoid the inconvenience of physically trying on multiple dresses, saving time and potentially reducing return rates.

4. Social Sharing and Influencer Potential: Users can share the personalized videos on social media, potentially generating user-generated content, increasing brand visibility, and attracting new customers.

5. Data-Driven Insights: The AI system can collect valuable data on user preferences, dress fit, and engagement, which can be used to refine recommendations, improve the user experience, and optimize inventory management.

 

Conclusion:

 

The implementation of an AI-powered personalized video try-on experience for dresses in a user's cart revolutionizes the online shopping process by providing an immersive and realistic visualization. By leveraging AI technology, this idea aims to increase user confidence, engagement, and satisfaction while reducing the uncertainty associated with online dress shopping.

Extract, Load, Transform (ELT) vs. Extract, Transform, Load (ETL) Which one is for you ?

 The choice between Extract, Load, Transform (ELT) and Extract, Transform, Load (ETL) depends on various factors and requirements specific to your data integration and processing needs. Here's an overview of both approaches:

Extract, Transform, Load (ETL):

ETL is a traditional data integration approach where data is first extracted from various sources, then transformed and cleansed according to specific business rules, and finally loaded into a target data store or data warehouse. The transformation step often involves aggregating, filtering, and joining data to meet the desired structure and quality standards before loading.

ETL is typically used when:

Source data needs significant transformation to match the target schema.

The target data warehouse requires a predefined structure and format.

Transformation processes are computationally intensive and benefit from dedicated ETL tools.

Extract, Load, Transform (ELT):

ELT, on the other hand, involves extracting data from various sources and loading it into a target data store or data lake as-is, without significant transformation. The transformation step occurs after loading, using the processing power of the target platform (e.g., data lake, cloud-based analytics service) to perform complex transformations and analytics on the raw data.

ELT is advantageous when:

Source data is already in a usable format and requires minimal transformation.

The target data platform has powerful computing capabilities that can handle data transformation at scale.

Flexibility is needed to explore and analyze raw data directly without predefined schemas or structures.

Factors to consider when choosing between ELT and ETL include the complexity of data transformations, the size and variety of data sources, the scalability requirements, the desired level of control over the transformation process, and the specific capabilities of the data integration tools or platforms you're using.

 However, ETL is still relevant in scenarios where complex transformations and strict data governance are required before loading data into a target warehouse.

How to handle azure cosmos db bulk insert speed limit error message

When performing bulk inserts in Azure Cosmos DB, there are certain limitations and considerations to keep in mind. One potential error message you might encounter related to bulk insert speed limits is:

"Request rate is large. More Request Units may be needed, so no further request is being sent. Please retry after some time, or adjust the RUs per second on your collection or database to allow for higher request rates."

This error message indicates that the request rate for your bulk inserts is exceeding the provisioned Request Units (RUs) per second for your Cosmos DB collection or database. Azure Cosmos DB uses Request Units as a measure of throughput, representing the cost of a request in terms of CPU, memory, and I/O resources.

1. Increase the provisioned RUs per second for your collection or database: By scaling up the RUs, you allocate more throughput capacity to handle higher request rates. You can adjust the RUs through the Azure portal, Azure CLI, or Azure PowerShell.

2. Split the bulk insert operation into multiple smaller batches: Instead of inserting all the data in a single bulk operation, divide it into smaller batches and perform the inserts over time. This approach helps distribute the request rate more evenly, preventing the error.

3. Implement client-side throttling: If you are using a custom application to perform the bulk inserts, you can introduce client-side throttling logic to control the request rate and avoid exceeding the provisioned RUs.

By following these steps, you should be able to mitigate the error related to bulk insert speed limits in Azure Cosmos DB.

How to use material tailwind in angular applicaiton?

 To use the Tailwind CSS framework in an Angular application, you'll need to follow these steps:

Step 1: Create a new Angular project (if you haven't already) by running the following command in your terminal:

ng new my-angular-app

Step 2: Install the necessary dependencies by navigating to your project directory and running the following command:

cd my-angular-app

npm install tailwindcss postcss autoprefixer

Step 3: Set up Tailwind CSS by creating a configuration file. Run the following command to generate the default configuration file:

npx tailwindcss init

This will create a `tailwind.config.js` file in your project root.

Step 4: Configure PostCSS to process Tailwind CSS by creating a `postcss.config.js` file in your project root and adding the following content:

module.exports = {

  plugins: [

    require('tailwindcss'),

    require('autoprefixer'),

  ],

};

Step 5: Open the `angular.json` file in your project root and locate the `"styles"` array. Add the following two lines to include Tailwind CSS and its dependencies:

"styles": [

  "./node_modules/tailwindcss/dist/base.css",

  "./node_modules/tailwindcss/dist/components.css",

  "./node_modules/tailwindcss/dist/utilities.css",

  "src/styles.css"

],

Step 6: Create a new file called `styles.css` in your `src` folder and import Tailwind CSS in it:

@import 'tailwindcss/base';

@import 'tailwindcss/components';

@import 'tailwindcss/utilities';

Step 7: Now you can start using Tailwind CSS classes in your Angular templates. For example, in your `app.component.html` file, you can add the following code:

<div class="bg-blue-500 p-4">

  <h1 class="text-white">Hello, Tailwind CSS!</h1>

</div>

That's it! You have successfully integrated Tailwind CSS into your Angular application. You can now use any Tailwind CSS class in your templates and stylesheets. Remember to rebuild your application (`ng serve` or `ng build`) for the changes to take effect.

How GPU different from CPU ?

 GPUs (Graphics Processing Units) and CPUs (Central Processing Units) are both types of processors, but they are designed to perform different tasks and have different architectural features. Here are some key differences between GPUs and CPUs:

1. Architecture: CPUs are general-purpose processors designed to handle a wide range of tasks. They typically have a few powerful cores optimized for sequential processing. On the other hand, GPUs are specialized processors primarily designed for rendering and manipulating images and graphics. They have a larger number of smaller cores optimized for parallel processing.

2. Parallelism: GPUs excel at performing multiple calculations simultaneously, which is known as parallel processing. They can execute thousands of threads concurrently, making them well-suited for tasks that can be divided into smaller parts that can be processed independently. CPUs, although they also support parallel processing, have a smaller number of cores and are more efficient at handling tasks that require sequential processing.

3. Memory: GPUs have dedicated high-bandwidth memory (VRAM) that is optimized for fast data transfer between the GPU cores and the memory. This is crucial for graphics-intensive applications that require quick access to large amounts of data. CPUs typically have smaller amounts of cache memory that is optimized for fast access to frequently used data but may need to rely on system RAM for larger data sets.

4. Instruction Set: CPUs typically have complex instruction sets that can handle a wide variety of tasks, including arithmetic, logic operations, and branching. They are designed to be flexible and versatile. GPUs have simpler instruction sets tailored for performing calculations on large data sets simultaneously. They are optimized for tasks such as matrix operations, which are commonly used in graphics rendering and machine learning.

5. Use Cases: CPUs are used for general-purpose computing tasks, such as running operating systems, executing software applications, and handling system-level operations. They are well-suited for tasks that require high single-threaded performance and complex decision-making. GPUs, on the other hand, are primarily used for graphics-intensive applications like gaming, video editing, and 3D modeling. They are also widely utilized in machine learning and scientific computing due to their ability to accelerate parallel computations.

It's important to note that the line between CPUs and GPUs has become somewhat blurred in recent years. Modern CPUs have incorporated some features typically found in GPUs, such as integrated graphics processing units (iGPUs). Additionally, GPUs have become more flexible and can now handle certain types of general-purpose computing tasks. This convergence has led to the emergence of hybrid processors like APUs (Accelerated Processing Units), which combine CPU and GPU functionality into a single chip.

How can I build a docker image with Azure-cli ?

 To build a Docker image with Azure CLI, you can follow these steps:

1. Create a Dockerfile: Open a text editor and create a new file called "Dockerfile" (without any file extension). This file will contain the instructions to build your Docker image.

2. Specify the base image: Add the following line to your Dockerfile to specify the base image to use. In this case, we'll use the official Azure CLI image from Microsoft.

   FROM mcr.microsoft.com/azure-cli

3. (Optional) Set any additional configurations: If you need to configure your image further, you can add additional instructions to the Dockerfile. For example, you might want to install additional tools or copy files into the image. Add the necessary instructions based on your requirements.

4. Build the Docker image: Open a terminal or command prompt and navigate to the directory where your Dockerfile is located. Run the following command to build the Docker image:

   docker build -t my-azure-cli-image .

   This command tells Docker to build an image with the tag "my-azure-cli-image" using the Dockerfile in the current directory (`.`).

5. Wait for the build to complete: Docker will execute the instructions in the Dockerfile and build the image. It may take some time, depending on your internet connection and the complexity of the Dockerfile.

6. Verify the image: Once the build process finishes successfully, you can verify that the image was created by running the following command:

  docker images

   This command lists all the Docker images available on your system. You should see your newly built image, "my-azure-cli-image," listed there.

Now you have successfully built a Docker image with Azure CLI. You can use this image to create containers and run Azure CLI commands within them.

.NET 6 minimal API hash password with salt

 In .NET 6, you can use the `Rfc2898DeriveBytes` class from the `System.Security.Cryptography` namespace to generate a hash-based password with a salt. Here's an example of how you can do this:

using System;

using System.Security.Cryptography;

using System.Text;

public class PasswordHasher

{

    private const int SaltSize = 16; // 128 bits

    private const int HashSize = 32; // 256 bits

    private const int Iterations = 10000;

    public static string HashPassword(string password)

    {

        byte[] salt = new byte[SaltSize];

        using (var rng = RandomNumberGenerator.Create())

        {

            rng.GetBytes(salt);

        }

        byte[] hash = HashPasswordWithSalt(password, salt);

        // Combine the salt and hash

        byte[] saltedHash = new byte[SaltSize + HashSize];

        Buffer.BlockCopy(salt, 0, saltedHash, 0, SaltSize);

        Buffer.BlockCopy(hash, 0, saltedHash, SaltSize, HashSize);

        return Convert.ToBase64String(saltedHash);

    }

    public static bool VerifyPassword(string password, string hashedPassword)

    {

        byte[] saltedHash = Convert.FromBase64String(hashedPassword);

        byte[] salt = new byte[SaltSize];

        byte[] hash = new byte[HashSize];

        // Extract the salt and hash from the combined bytes

        Buffer.BlockCopy(saltedHash, 0, salt, 0, SaltSize);

        Buffer.BlockCopy(saltedHash, SaltSize, hash, 0, HashSize);

        byte[] computedHash = HashPasswordWithSalt(password, salt);

        // Compare the computed hash with the stored hash

        return SlowEquals(hash, computedHash);

    }

    private static byte[] HashPasswordWithSalt(string password, byte[] salt)

    {

        using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, Iterations))

        {

            return deriveBytes.GetBytes(HashSize);

        }

    }

    // Compares two byte arrays in a way that is resistant to timing attacks

    private static bool SlowEquals(byte[] a, byte[] b)

    {

        uint diff = (uint)a.Length ^ (uint)b.Length;

        for (int i = 0; i < a.Length && i < b.Length; i++)

        {

            diff |= (uint)(a[i] ^ b[i]);

        }

        return diff == 0;

    }

}

You can use the `HashPassword` method to hash a password and store it securely in your application's database. The `VerifyPassword` method can be used to compare a user-provided password with the stored hashed password to verify if they match.

The feature 'global using directive' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version

 The error message you're seeing indicates that the "global using directive" feature is currently unsupported in the version of C# you're using. To resolve this issue, you can follow these steps:

Step 1: Open the `.csproj` file of your project.

Step 2: Locate the `<LangVersion>` element within the `<PropertyGroup>` section.

Step 3: Modify the `<LangVersion>` element to include the "preview" language version. It should look like this:

<PropertyGroup>

  <LangVersion>preview</LangVersion>

</PropertyGroup>

Step 4: Save the changes to the `.csproj` file.

Step 5: Rebuild your project.

By setting the language version to "preview," you enable the use of preview features, including the "global using directive." However, please note that preview features are subject to change and may not be suitable for production environments. It's important to exercise caution when using preview features and to consider upgrading to a stable release once available.

After applying these changes, rebuild your project and verify if the error is resolved.

minimal api authentication JWT .NET 6

 To implement minimal API authentication with JWT (JSON Web Tokens) in .NET 6, you can follow these steps:

Step 1: Create a new .NET 6 Minimal API project.

Step 2: Install the required NuGet packages:

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer

dotnet add package System.IdentityModel.Tokens.Jwt

Step 3: Configure JWT authentication in the `Program.cs` file:

using Microsoft.AspNetCore.Authentication.JwtBearer;

using Microsoft.IdentityModel.Tokens;

var builder = WebApplication.CreateBuilder(args);

// JWT Configuration

var jwtSettings = builder.Configuration.GetSection("JwtSettings");

var key = Encoding.ASCII.GetBytes(jwtSettings["SecretKey"]);

var tokenValidationParameters = new TokenValidationParameters

{

    ValidateIssuerSigningKey = true,

    IssuerSigningKey = new SymmetricSecurityKey(key),

    ValidateIssuer = false,

    ValidateAudience = false

};

builder.Services.AddAuthentication(options =>

{

    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;

    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;

})

.AddJwtBearer(options =>

{

    options.TokenValidationParameters = tokenValidationParameters;

});

builder.Services.AddSingleton(tokenValidationParameters);

Step 4: Configure JWT secret key and issuer in the `appsettings.json` file:

{

  "JwtSettings": {

    "SecretKey": "your_secret_key_here"

  }

}

Step 5: Protect your API endpoints with the `[Authorize]` attribute:

using Microsoft.AspNetCore.Authorization;

app.MapGet("/protected", () =>

{

    return "This is a protected endpoint.";

}).RequireAuthorization(); // Requires authentication for this endpoint

Step 6: Generate JWT tokens during the login process:

using System.IdentityModel.Tokens.Jwt;

using Microsoft.Extensions.Configuration;

using Microsoft.IdentityModel.Tokens;

app.MapPost("/login", async (LoginModel model, IConfiguration configuration) =>

{

    // Validate the user credentials and generate JWT token

    if (IsValidUser(model.Username, model.Password))

    {

        var tokenHandler = new JwtSecurityTokenHandler();

        var jwtSettings = configuration.GetSection("JwtSettings");

        var key = Encoding.ASCII.GetBytes(jwtSettings["SecretKey"]);

        var tokenDescriptor = new SecurityTokenDescriptor

        {

            Subject = new ClaimsIdentity(new[]

            {

                new Claim(ClaimTypes.Name, model.Username)

            }),

            Expires = DateTime.UtcNow.AddHours(1),

            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)

        };

        var token = tokenHandler.CreateToken(tokenDescriptor);

        var tokenString = tokenHandler.WriteToken(token);

        return Results.Ok(new { Token = tokenString });

    }

    else

    {

        return Results.Unauthorized();

    }

});

Step 7: Test the protected endpoints by including the JWT token in the `Authorization` header of the request:

GET /protected HTTP/1.1

Host: localhost:5000

Authorization: Bearer <your_token_here>

That's it! With these steps, you have implemented minimal API authentication with JWT in .NET 6 using the Minimal API approach. Remember to customize the authentication and authorization logic according to your requirements.

How to save a file to Azure Storage Account through App Service?

 To save a file to Azure Storage Account through an App Service, you can follow these general steps:

1. Set up an Azure Storage Account: Create a storage account in the Azure portal if you haven't already done so. Note down the storage account name and access key, as you will need them later.

2. Configure App Service settings: In the Azure portal, navigate to your App Service and go to the "Configuration" section. Add or modify the following application settings:

   - `AzureStorageAccountName`: Set this to your Azure Storage Account name.

   - `AzureStorageAccountKey`: Set this to the access key of your Azure Storage Account.

   - `AzureStorageContainerName`: Specify the name of the container within the storage account where you want to store the file.

3. Add code to your application: Depending on the programming language and framework you are using for your App Service, the code implementation may vary. Here's an example using C# and the Azure Storage SDK:

   using Microsoft.WindowsAzure.Storage;

   using Microsoft.WindowsAzure.Storage.Blob;

   using System.IO;

   // Retrieve the storage account connection string and container name from app settings

   var storageAccountName = System.Environment.GetEnvironmentVariable("AzureStorageAccountName");

   var storageAccountKey = System.Environment.GetEnvironmentVariable("AzureStorageAccountKey");

   var containerName = System.Environment.GetEnvironmentVariable("AzureStorageContainerName");

   // Create a CloudStorageAccount object

   var storageAccount = new CloudStorageAccount(

       new StorageCredentials(storageAccountName, storageAccountKey), true);

   // Create a CloudBlobClient object

   var blobClient = storageAccount.CreateCloudBlobClient();

   // Get a reference to the container

   var container = blobClient.GetContainerReference(containerName);

   // Create the container if it doesn't exist

   await container.CreateIfNotExistsAsync();

   // Set the permissions for the container (optional)

   await container.SetPermissionsAsync(new BlobContainerPermissions

   {

       PublicAccess = BlobContainerPublicAccessType.Blob

   });

   // Create a CloudBlockBlob object

   var blob = container.GetBlockBlobReference("filename.txt");

   // Upload the file to the blob

   using (var fileStream = File.OpenRead("path/to/file.txt"))

   {

       await blob.UploadFromStreamAsync(fileStream);

   }

   

   In this example, make sure to replace `"filename.txt"` with the desired name of the file in the storage account and `"path/to/file.txt"` with the actual path of the file you want to upload.

4. Deploy and test: Deploy your App Service with the updated code and test the functionality by uploading a file. The file should be saved to the specified Azure Storage Account and container.

Note: Ensure that the appropriate SDK or library is installed for your programming language and framework to interact with Azure Storage, such as `Microsoft.WindowsAzure.Storage` for C#/.NET.

Optimizing Azure SQL Performance: Bulk Inserts and Commit Control in JDBC

 There are still some ways you can improve the performance of your inserts. Here are a few suggestions:

1. Use Parameterized Queries: You're already using parameterized queries, which is good. It helps with query performance and prevents SQL injection. Make sure the column types in your table match the data types you're setting in the Prepared Statement.

2. Increase Batch Size: Instead of executing the batch every 10,000 rows, you can try increasing the batch size to a larger number. This can help reduce the number of round trips to the database and improve performance. Experiment with different batch sizes to find the optimal value for your specific scenario.

3. Use Connection Pooling: You can use HikariCP for connection pooling, which is recommended for efficient connection management. Connection pooling helps reuse existing connections instead of creating new connections for each insert, which can significantly improve performance.

4. Disable Auto-Commit: By default, JDBC commits each individual statement execution, which can be costly for bulk inserts. You can try disabling auto-commit mode before executing the batch and commit explicitly after the batch completes. This can help reduce the overhead of committing after every single statement.

Here's an updated version of your code incorporating these suggestions:

public void saveAllJdbc(List<JdbcDetail> jdbcDetails) {
    String sql = String.format("INSERT INTO %s VALUES (?, ?, ?, ?)", "my-table");

    try (Connection connection = hikariDataSource.getConnection();
         PreparedStatement statement = connection.prepareStatement(sql)) {

        int counter = 0;

        connection.setAutoCommit(false);  // Disable auto-commit

        for (JdbcDetail row : jdbcDetails) {
            statement.clearParameters();
            statement.setInt(1, row.getQuantity());
            statement.setDate(2, Date.valueOf(row.getDate()));
            statement.setFloat(3, row.getId());
            statement.setInt(4, row.getNum());

            statement.addBatch();

            if ((counter + 1) % 10000 == 0) {
                statement.executeBatch();
                statement.clearBatch();
                connection.commit();  // Explicitly commit the batch
            }

            counter++;
        }

        statement.executeBatch();  // Execute any remaining statements in the batch
        connection.commit();  // Commit the final batch

        connection.setAutoCommit(true);  // Re-enable auto-commit

    } catch (Exception e) {
        e.printStackTrace();
    }
}

By increasing the batch size and disabling auto-commit, you should see improvements in the performance of your insert operations in Azure SQL. Remember to experiment with different batch sizes to find the optimal value for your specific scenario.