Forem: Rmauro Dev

Generating Images from Text with C# and Open AI DALL-E

Ricardo — Sun, 16 Apr 2023 19:05:30 +0000

With the use of .NET C#, we can develop a POC (Proof of Concept) that uses the Open AI DALL-E model to generate images from text input.

In this blog post, we will explore the steps to develop a C# Console Application using Open AI's DALL-E model to generate images from text.

Also, check out my blog with other articles --> https://rmauro.dev

💬 What is DALL-E from Open AI

DALL-E can generate images of almost anything, from a yellow submarine to a pig with wings. It has been trained on a massive dataset of images and textual descriptions, allowing it to learn how to generate images from natural language input. In this article, we will explore how to integrate C# with DALL-E to generate images using code.

DALL-E Generated

🧵 Development with C

In this project we're going to use Visual Studio and C# with .NET 6 to create a Console Application.

💡 You may need to do some tweaks if you intend to use another.NET version.

Step 1: Console Application and dependencies

Let's create our Console Application with C# and .NET 6 let's install the dependencies.

Project Name : ConsoleAppOpenAI.DALL_E

dotnet add Microsoft.Extensions.Http

👇 these are for loading configuration from JSON files
dotnet add Microsoft.Extensions.Configuration
dotnet add Microsoft.Extensions.Configuration.Json

👇 this is optional
dotnet add Microsoft.Extensions.Configuration.UserSecrets

Commands to install the dependencies

Installed Dependencies

Step 2: IOpenAIProxy Interface

Within this interface, we'll expose only the methods to Generate and Download the images from Open AI.

namespace ConsoleAppOpenAI.DALL_E.HttpServices;

public interface IOpenAIProxy
{
    //👇 Send the Prompt Text with and return a list of image URLs
    Task<GenerateImageResponse> GenerateImages(
        GenerateImageRequest prompt, 
        CancellationToken cancellation = default);

    //👇 Download the Image as byte array
    Task<byte[]> DownloadImage(string url);
}

IOpenAIProxy.cs File

Step 3: Generate Image Models

Let's define our models using records. Records simplify the reading since they are only POCO classes.

namespace ConsoleAppOpenAI.DALL_E.HttpServices
{
    public record class GenerateImageRequest(
        string Prompt, 
        int N, 
        string Size);

    public record class GenerateImageResponse(
        long Created, 
        GeneratedImageData[] Data);

    public record class GeneratedImageData(string Url);
}

Generate Image Models DTO

Step 4: Create an Open AI Account

To use the OpenAI API, we need to create an account on the OpenAI platform. The registration process is straightforward and can be completed in a few minutes.

We just need to visit the OpenAI website at https://platform.openai.com/overview.
Then click on the "Sign Up" button in the top right corner.
Click on the button to start the registration process.

Step 5: Set up the Configuration File / appsettings.json

To access the DALL-E model, we'll need to set up the Subscription Id and API key for our application.

Collect them from these menus:

Update the appsettings.json or secrets.json file with the values.

{
  "OpenAi": {

    "OrganizationId": "{Subscription Id goes here}",
    "ApiKey": "{API Key goes here}",

    "Url": "https://api.openai.com",
    "DALL-E": {
      "Size": "1024x1024",
      "N": 1
    }
  }
}

appsettings.json file

💡 Don't forget to set Copy to Output Directory as Copy if newer for appsettings.json.

Step 6: Open AI HTTP Service Implementation

Create a class named OpenAIHttpService with a single constructor receiving IConfiguration and read the configuration we just set in place.

using ConsoleAppOpenAI.DALL_E.HttpServices;
using Microsoft.Extensions.Configuration;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;

namespace ConsoleAppOpenAI.DALL_E.Services;

public class OpenAIHttpService : IOpenAIProxy
{
    readonly HttpClient _httpClient;

    readonly string _subscriptionId;

    readonly string _apiKey;

    public OpenAIHttpService(IConfiguration configuration)
    {
        //👇 reading settings from the configuration file
        var openApiUrl = configuration["OpenAi:Url"] ?? throw new ArgumentException(nameof(configuration));
        _httpClient = new HttpClient { BaseAddress = new Uri(openApiUrl) };

        _subscriptionId = configuration["OpenAi:SubscriptionId"];
        _apiKey = configuration["OpenAi:ApiKey"];
    }

    public async Task<GenerateImageResponse> GenerateImages(GenerateImageRequest prompt, CancellationToken cancellation = default)
    {
        throw new NotImplementedException();
    }

    public async Task<byte[]> DownloadImage(string url)
    {
        throw new NotImplementedException();
    }
}

Next should be the implementation of the GenerateImages() method:

public async Task<GenerateImageResponse> GenerateImages(GenerateImageRequest prompt, CancellationToken cancellation = default)
{
    using var rq = new HttpRequestMessage(HttpMethod.Post, "/v1/images/generations");

    var jsonRequest = JsonSerializer.Serialize(prompt, new JsonSerializerOptions
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    });

    //serialize the content to JSON and set the correct content type
    rq.Content = new StringContent(jsonRequest);
    rq.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

    //👇 Including the Authorization Header with API Key
    var apiKey = _apiKey;
    rq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

    //👇 Including the Subscription Id Header
    var subscriptionId = _subscriptionId;
    rq.Headers.TryAddWithoutValidation("OpenAI-Organization", subscriptionId);

    var response = await _httpClient.SendAsync(rq, HttpCompletionOption.ResponseHeadersRead, cancellation);

    response.EnsureSuccessStatusCode();

    var content = response.Content;

    var jsonResponse = await content.ReadFromJsonAsync<GenerateImageResponse>(cancellationToken: cancellation);

    return jsonResponse;
}

Last the DownloadImage() method implementation:

public async Task<byte[]> DownloadImage(string url)
{
    var buffer = await _httpClient.GetByteArrayAsync(url);

    return buffer;
}

Step 7: Consuming the APIs

Back to Program.cs file let's wire everything together and start calling the APIs to generate images.

using ConsoleAppOpenAI.DALL_E.HttpServices;
using ConsoleAppOpenAI.DALL_E.Services;
using Microsoft.Extensions.Configuration;
using System.Reflection;

Console.WriteLine("Starting commandline for DALL-E [Open AI]");

var config = BuildConfig();

IOpenAIProxy aiClient = new OpenAIHttpService(config);

Console.WriteLine("Type your first Prompt");
var msg = Console.ReadLine();

var nImages = int.Parse(config["OpenAi:DALL-E:N"]);
var imageSize = config["OpenAi:DALL-E:Size"];
var prompt = new GenerateImageRequest(msg, nImages, imageSize);

var result = await aiClient.GenerateImages(prompt);

foreach (var item in result.Data)
{
    Console.WriteLine(item.Url);

    var fullPath = Path.Combine(Directory.GetCurrentDirectory(), $"{Guid.NewGuid()}.png");
    var img = await aiClient.DownloadImage(item.Url);

    await File.WriteAllBytesAsync(fullPath, img);

    Console.WriteLine("New image saved at {0}", fullPath);
}

Console.WriteLine("Press any key to exit");
Console.ReadKey();

static IConfiguration BuildConfig()
{
    var dir = Directory.GetCurrentDirectory();
    var configBuilder = new ConfigurationBuilder()
        .AddJsonFile(Path.Combine(dir, "appsettings.json"), optional: false)
        .AddUserSecrets(Assembly.GetExecutingAssembly());

    return configBuilder.Build();
}

With all of this, we should have a running POC integrating with DALL-E model.

Generate our very first Image

Here is the output of my first try.

Prompt: Wide and green garden with a lot of flowers, with sunflowers, and a small dog running around

Take a look at this beautiful image generated by our application and DALL-E.

DALL-E Generated

Conclusion

Integrating C# with DALL-E is a straightforward process that allows us to generate images programmatically.

By using Open AI's API, we can easily send textual descriptions and receive high-quality images in response.

This integration opens up many possibilities, such as generating images for data visualization, creating custom artwork, or automating image creation tasks. As DALL-E continues to improve, we can expect even more exciting applications in the future.

Source code at: https://github.com/ricardodemauro/OpenAILabs.Console

Posted at: https://rmauro.dev/generating-images-from-text-with-csharp-and-open-ai-dall-e/

Creating a Serilog Custom Enricher

Ricardo — Fri, 14 Apr 2023 15:41:21 +0000

Serilog is a popular logging library for .NET that provides a flexible and extensible way to log messages from applications. One of the key features of Serilog is the ability to enrich log events with additional contextual information that can help in troubleshooting and debugging.

In this blog post, we will explore how to create a custom enricher with Serilog to add custom properties to log events.

📢Development

To create a custom enricher with Serilog , we need to define a class that implements the ILogEventEnricher interface.

public interface ILogEventEnricher
{
    void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory);
}

ILogEventEnricher.cs Interface

This interface contains a single method Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory) that we need to implement to add custom properties to log events.

Let's start by creating a new class called AspNetCoreEnvironmentEnricher that implements the ILogEventEnricher interface:

using Serilog.Core;
using Serilog.Events;
using System;

namespace Serilog.Labs.CustomEnrichers.Enrichers
{
    //class must implement interface ILogEventEnricher
    public class AspNetCoreEnvironmentEnricher : ILogEventEnricher
    {
        static readonly string _aspNetEnvironment;

        /// <summary>
        /// static constructor to load the environment variable
        /// </summary>
        static AspNetCoreEnvironmentEnricher()
        {
            _aspNetEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
        }

        public void Enrich(
            LogEvent logEvent, 
            ILogEventPropertyFactory propertyFactory)
        {
            var enrichProperty = propertyFactory
                .CreateProperty(
                    "AspNetCoreEnvironment", 
                    _aspNetEnvironment);

            logEvent.AddOrUpdateProperty(enrichProperty);
        }
    }
}

AspNetCoreEnvironmentEnricher.cs implementation

The Enrich method is called for each log event, and we can use it to add custom properties to the logEvent parameter. The propertyFactory parameter can be used to create new properties that we can add to the log event.

Using AspNetCoreEnvironmentEnricher

Now that we have our custom enricher class, let's use it with Serilog. We can add it to the logger configuration like this:

Log.Logger = new LoggerConfiguration()
    .Enrich.With(new AspNetCoreEnvironmentEnricher())
    .WriteTo.Console(
        outputTemplate: "[{AspNetCoreEnvironment} {Level:u3}] {Message:lj}{NewLine}{Exception}")
    .CreateLogger();

Using the AspNetCoreEnvironmentEnricher

In this example, we added our custom enricher to the logger configuration using the Enrich.With method. We passed the current user's name "Alice" to the constructor of our enricher.

Now, when we log a message, the UserName property will be added to the log event:

Log.Information("Hello, world!");

/*Will Output
[Information Development] Hello, world!
*/

😎Conclusion

Creating a custom enricher with Serilog is a simple and powerful way to add contextual information to log events.

By implementing the ILogEventEnricher interface and using the propertyFactory parameter, we can add any custom properties we need to help in troubleshooting and debugging our applications.

Getting Started with Chat GPT integration in a .NET C# Console Application

Ricardo — Thu, 06 Apr 2023 15:34:47 +0000

With the use of C# , we can develop a console application that uses the Chat GPT model to generate human-like responses to input.

In this blog post, we will explore the steps to develop a console application using OpenAI's Chat GPT model using C#.

OpenAI is a leading organization in the field of artificial intelligence, and one of its popular AI models is the Chat GPT (Generative Pretrained Transformer).

What are OpenAI and Chat GPT?

OpenAI is a prominent organization that develops AI for various applications, including natural language processing. One of their popular AI models is the Chat GPT, a generative language model that uses a transformer architecture to process input text and generate human-like responses. It's commonly used for chatbots and other natural language processing tasks.

Development with source code

To develop a console application using OpenAI's Chat GPT model in C#, we will follow these steps:

Step 1: Install Standard.AI.OpenAI C# library

To use the Chat GPT model in C#, we will need to install the Standard.AI.OpenAI C# library. We can install the library using the following command:

dotnet add Standard.AI.OpenAI

Step 2: Create an OpenAI account

To use the OpenAI API, we need to create an account on the OpenAI platform. The registration process is straightforward and can be completed in a few minutes.

First, we need to visit the OpenAI website at https://platform.openai.com/overview. We should see the "Sign Up" button in the top right corner. Click on the button to start the registration process.

Note that OpenAI's API is currently in beta, and access to the API may be limited or subject to approval. Additionally, OpenAI charges for API usage, so it's essential to keep track of usage and billing to avoid any unexpected charges.

If you are getting started, don't worry. They usually give 18 dollars as a jump start without the need of a credit card.

Step 3: Create the class OpenAIProxy

Within this class, we'll encapsulate the logic to access OpenAI APIs.

Let's define our interface first.

using Standard.AI.OpenAI.Models.Services.Foundations.ChatCompletions;

namespace ConsoleAppOpenAI;

public interface IOpenAIProxy
{
    Task<ChatCompletionMessage[]> SendChatMessage(string message);
}

This is the IOpenAIProxy.cs file

That is right. We'll expose only the method responsible for sending and receiving messages.

Step 4: Create the implementation class OpenAIProxy.cs

Let's jump to the implementation now.

using Standard.AI.OpenAI.Clients.OpenAIs;
using Standard.AI.OpenAI.Models.Configurations;
using Standard.AI.OpenAI.Models.Services.Foundations.ChatCompletions;

namespace ConsoleAppOpenAI;

public class OpenAIProxy : IOpenAIProxy
{
    readonly OpenAIClient openAIClient;

    readonly List<ChatCompletionMessage> _messages;

    public OpenAIProxy(string apiKey, string organizationId)
    {
        var openAIConfigurations = new OpenAIConfigurations
        {
            ApiKey = apiKey,
            OrganizationId = organizationId
        };

        openAIClient = new OpenAIClient(openAIConfigurations);

        _messages = new();
    }

    void StackMessages(params ChatCompletionMessage[] message)
    {
        _messages.AddRange(message);
    }

    static ChatCompletionMessage[] ToCompletionMessage(
        ChatCompletionChoice[] choices)
        => choices.Select(x => x.Message).ToArray();

    public Task<ChatCompletionMessage[]> SendChatMessage(string message)
    {
        var chatMsg = new ChatCompletionMessage() 
        { 
            Content = message, 
            Role = "user" 
        };
        return SendChatMessage(chatMsg);
    }

    async Task<ChatCompletionMessage[]> SendChatMessage(
        ChatCompletionMessage message)
    {
        StackMessages(message);

        var chatCompletion = new ChatCompletion
        {
            Request = new ChatCompletionRequest
            {
                Model = "gpt-3.5-turbo",
                Messages = _messages.ToArray(),
                Temperature = 0.2,
                MaxTokens = 800
            }
        };

        var result = await openAIClient
            .ChatCompletions
            .SendChatCompletionAsync(chatCompletion);

        var choices = result.Response.Choices;

        var messages = ToCompletionMessage(choices);

        StackMessages(messages);

        return messages;
    }
}

This is the OpenAIProxy.cs file

Step 5: Set up the API key

To access the Chat GPT model, we'll need to set up the API key in our application. We can set up the API key using the following code:

Back to Program.cs now.

IOpenAIProxy chatOpenAI = new OpenAIProxy(
    apiKey: "YOUR-API-KEY",
    organizationId: "YOUR-ORGANIZATION-ID");

This code sets up the API key that we'll use to access the Chat GPT model.

Where to get API Key and Organization ID

Step 6: Use the Chat GPT model in our application

Once we've set up the API key, we can use the Chat GPT model in our application using the following code:

var msg = Console.ReadLine();

do
{
    var results = await chatOpenAI.SendChatMessage(msg);

    foreach (var item in results)
    {
        Console.WriteLine($"{item.Role}: {item.Content}");
    }
    Console.WriteLine("Next Prompt:");
    msg = Console.ReadLine();
} while (msg != "bye");

This code creates an infinite loop that prompts the user for input and generates a response using the Chat GPT model. If the user inputs "bye," the loop will break, and the application will exit.

Final Touches

After we get everything working we can make it a little more professional using the following packages:

Spectre.Console - better display in the output Console
Humanizer.Core - Formatting the response
Microsoft.Extensions.Configuration.Json - Read the configuration from Json files

You can check it out on the source code below the implementation.

Here is the final look.

Running Application

Source Code

https://github.com/ricardodemauro/OpenAILabs.Console

Conclusion

In this blog post, we explored how to develop a console application using OpenAI's Chat GPT model in C#.

We installed the Standard.AI.OpenAI C# library, set up the API key, and used the Chat GPT model to generate human-like responses to input. The Chat GPT model is powerful.

By the way. This blog post was created with the help of Chat GPT.

Don't forget to Like, Comment, and most important --> Share It.

8 Actions for Hardening your Linux Server exposed on the internet

Ricardo — Mon, 12 Sep 2022 18:52:00 +0000

Exposing virtual machines to the internet it's not an easy task. Often managed using an SSH connection we must secure our machines as much as we can against hacker attacks.

Let's go through some often and ease configurations that will make it an attacker hard if trying to access your machine.

💬 In this issue

Creating a non-root user and use eventually elevated privileged
Enabling UFW Uncomplicated Firewall
Unattended Upgrades
Hardening the SSH Access
- Change the default Port for SSH
- Use SSH Keys instead of Password
- Disable Password Login
- Disable Root Login over SSH
- Use config file in SSH client for easier connection

👉 Information used in our lab

User: root
Password: generated with a password generator
Description: Our Root user

User: secondary
Password: generated with a password generator
Description: Non Root user for daily basis access

Operating System: Ubuntu Server 20.04 - but it also working for different flavors of Linux.

Creating a non-root user

First thing first: Never use the root user for non-privilege tasks.

To accomplish that let's create a non-root user and use the sudo command to elevate our privileges only when necessary.

Logged as the root user let's create a non-root user called secondary. Execute the following command in our bash shell.

# create a regular user with name secondary
$ adduser secondary

Creating the Secondary User

We should answer some questions (starting with the password) and we shall have the user.

Now we have a user with fewer privileges. Next step is to grant the use sudo command when necessary.

Add to Sudo Group

Run usermod command to include secondary into sudo group.

# includes the secondary into sudo group
$ usermod -aG sudo secondary

Now we're able to use sudo in front of a command to run as administrative rights.

Enabling UFW Uncomplicated Firewall

UFW is the default firewall system (under the hood is the great IPTables) in Ubuntu Server.

With the use of ufw it's very simple to allow or block a port.

# allow port 22
$ sudo ufw allow 22

Don't forget to use sudo we should be using the secondary user instead of the root

# Deny all incoming by default, allow outgoing, and finally enable the ufw service
$ sudo ufw default deny incoming
$ sudo ufw default allow outgoing
$ sudo ufw enable

Deny all incoming by default, allow outgoing, and finally enable the ufw service

# display status of ufw
$ sudo ufw status

Displaying Status of ufw Service

Great. Now we have ufw up and running.

Adding Unattended Upgrades

Unattended-Upgrade is a service that regularly checks and updates the OS packages.

The purpose of unattended-upgrades is to keep the computer current with the latest security (and other) updates automatically.

https://wiki.debian.org/UnattendedUpgrades

# Install unattended upgrades and enable it

$ sudo apt install unattended-upgrades

$ sudo systemctl status unattended-upgrades.service

After installing just enable the service and we should be good.

Unattended upgrades Status

The default configuration will automatically retrieve new package updates for most of the packages included in the Ubuntu repositories.

Hardening the SSH Configuration

Most Linux servers are administered remotely using SSH using OpenSSH technology. Which is the default SSH server software used within Ubuntu.

This is one of the major vectors of attack by hackers on Linux exposed on the internet. Let's work on improving the configurations of our SSH server.

Using SSH keys instead of passwords

SSH keys are the recommended way to log into any Linux server environment remotely.

Back in our client machine (not on the server) let's create a pair of keys - private and public keys. This also works on Windows 10/11.

$ ssh-keygen

You can specify a different location to save the keys if you like.

Generating the Public and Private Keys

The next step is to copy the SSH key to the Ubuntu server.

$ cat /home/{username}/.ssh/id_rsa.pub

Copy the content output to the transfer area.

Back into our server

# create .ssh if not created
$ sudo mkdir -p ~/.ssh

# copy the public key to authorized_keys file
$ sudo echo public_key_string >> ~/.ssh/authorized_keys

# remove all permissions on .ssh folder
$ sudo chmod -R go= ~/.ssh

# adding read permission to our user - our scenario is secondary - on .ssh folder
$ chown -R secondary:secondary ~/.ssh

Now we have the public key generated by our client machine in the server in the property location and with permissions in place.

This is it. Now we're able to log in using the recently created SSH Key. Let's try.

# ssh -i {key path}
$ ssh -i $HOME/.ssh/id_rsa secondary@{SERVER-IP}

Using SSH Key to log into the Server

Changing default Port for SSH

Open the SSH configuration file sshd_config with a text editor.

$ sudo nano /etc/ssh/sshd_config

Look for the entry Port 22 - it could be commented on. Replace it with the desired value - port between 1024 and 65536

. . .
Port 2222
. . .

Port Configuration

Save and Restart the OpenSSH service.

$ sudo systemctl restart ssh

Restarting the SSH service

Disable Password Authentication over SSH

Change property to PasswordAuthentication no

. . .
PasswordAuthentication no
. . .

Password Authentication Configuration

Disable Root User Login

Change property to PermitRootLogin no

. . .
PermitRootLogin no
. . .

Password Authentication Configuration

Tweaking some other sshd_config Configurations

Open the config file sshd_config one more time

$ sudo nano /etc/ssh/sshd_config

. . .
MaxAuthTries 3
. . .

. . .
PermitEmptyPasswords no
. . .

Test and Restart the SSH Service to reflect the new configuration

# test the configuration changes
$ sudo sshd -t

# restart the service and load the new configuration
$ sudo systemctl restart ssh

Using ssh config file on SSH Client

Adding a config file in the .ssh folder on the ssh client allows us to define the key, host, user, and other configurations by default per connection.

In our Client's machine

Create the config file in ~/.ssh/config location

# THIS IS OUR CLIENT - NOT OUR UBUNTU SERVER
$ nano ~/.ssh/config

Past the following content.

# connection name
Host ssh-server

   # host address (ip or hostname)
   Hostname 192.168.0.100

   # port of ssh server
   Port 2222

   # user
   User secondary

   # private key to use
   IdentityFile ~/.ssh/id_rsa_locaweb_secondary

config file

Then we can connect using only the connection name

$ ssh ssh-server

Final thoughts

Wow, finally we made it. That is enough!

Of course, we can keep going hardening it even more adding more protection - it never stops.

Share in the comments section what you would do to make it even better or different.