Die KI-Revolution ist da und mit ihr kommt eine st?ndig wachsende Liste leistungsstarker Modelle, die Texte generieren, Bilder erstellen und komplexe Probleme l?sen k?nnen. Aber seien wir ehrlich: Bei so vielen Optionen kann es überw?ltigend sein, herauszufinden, welches Modell am besten zu Ihrem Projekt passt. Was w?re, wenn es eine M?glichkeit g?be, diese Modelle schnell zu testen, ihre Ergebnisse in Aktion zu sehen und zu entscheiden, welches Modell in Ihr Produktionssystem integriert werden soll?

Geben Sie Hugging Face’s Inference API ein – Ihre Abkürzung zur Erkundung und Nutzung modernster KI-Modelle. Durch das Angebot einer Plug-and-Play-L?sung entf?llt der Aufwand für das Einrichten, Hosten oder Trainieren von Modellen. Egal, ob Sie über eine neue Funktion nachdenken oder die F?higkeiten eines Modells bewerten, Hugging Face macht die KI-Integration einfacher als je zuvor.

In diesem Blog begleite ich Sie durch die Erstellung einer einfachen Backend-Anwendung mit Spring Boot, mit der Sie KI-Modelle mühelos testen und bewerten k?nnen. Das k?nnen Sie erwarten:

? Was Sie lernen werden

• Zugriff auf KI-Modelle: Erfahren Sie, wie Sie die Inferenz-API von Hugging Face verwenden, um Modelle zu erkunden und zu testen.
• Erstellen Sie ein Backend: Erstellen Sie eine Spring Boot-Anwendung, um mit diesen Modellen zu interagieren.
• Testmodelle: Richten Sie Endpunkte für die Text- und Bildgenerierung mithilfe von Beispielaufforderungen ein und testen Sie sie.

Am Ende verfügen Sie über ein praktisches Tool, mit dem Sie verschiedene KI-Modelle testen und fundierte Entscheidungen über deren Eignung für die Anforderungen Ihres Projekts treffen k?nnen. Wenn Sie bereit sind, die Lücke zwischen Neugier und Umsetzung zu schlie?en, legen wir los!

?? Warum Hugging Face Inference API?

Deshalb ist Hugging Face ein Game-Changer für die KI-Integration:

• Benutzerfreundlichkeit: Modelle müssen nicht trainiert oder bereitgestellt werden – rufen Sie einfach die API auf.
• Vielfalt: Greifen Sie auf über 150.000 Modelle für Aufgaben wie Texterstellung, Bilderstellung und mehr zu.
• Skalierbarkeit: Perfekt für Prototyping und Produktionseinsatz.

? Was Sie bauen werden

Wir erstellen QuickAI, eine Spring Boot-Anwendung, die:

1. Generiert Text: Erstellen Sie kreative Inhalte basierend auf einer Eingabeaufforderung.
2. Erzeugt Bilder: Wandeln Sie Textbeschreibungen in visuelle Darstellungen um.
3. Stellt API-Dokumentation bereit: Verwenden Sie Swagger, um die API zu testen und mit ihr zu interagieren.

? Erste Schritte

Schritt 1: Melden Sie sich für Hugging Face an

Gehen Sie zu Huggingface.co und erstellen Sie ein Konto, falls Sie noch keins haben.

Schritt 2: Holen Sie sich Ihren API-Schlüssel

Navigieren Sie zu Ihren Kontoeinstellungen und generieren Sie einen API-Schlüssel. Mit diesem Schlüssel kann Ihre Spring Boot-Anwendung mit der Inferenz-API von Hugging Face interagieren.

Schritt 3: Modelle erkunden

Schauen Sie sich den Hugging Face Model Hub an, um Modelle für Ihre Bedürfnisse zu finden. Für dieses Tutorial verwenden wir:

• Ein Textgenerierungsmodell (z. B. HuggingFaceH4/zephyr-7b-beta).
• Ein Bilderzeugungsmodell (z. B. ?stableabilityai/stable-diffusion-xl-base-1.0“).

?? Einrichten des Spring Boot-Projekts

Schritt 1: Erstellen Sie ein neues Spring Boot-Projekt

Verwenden Sie Spring Initializr, um Ihr Projekt mit den folgenden Abh?ngigkeiten einzurichten:

• Spring WebFlux: Für reaktive, nicht blockierende API-Aufrufe.
• Lombok: Um den Boilerplate-Code zu reduzieren.
• Swagger: Für API-Dokumentation.

Schritt 2: Fügen Sie die Konfiguration ?Umarmendes Gesicht“ hinzu

Fügen Sie Ihren Hugging Face-API-Schlüssel und die Modell-URLs zur Datei application.properties hinzu:

huggingface.text.api.url=https://api-inference.huggingface.co/models/your-text-model
huggingface.api.key=your-api-key-here
huggingface.image.api.url=https://api-inference.huggingface.co/models/your-image-model

? Was kommt als n?chstes?

Lassen Sie uns in den Code eintauchen und die Dienste für die Text- und Bildgenerierung erstellen. Bleiben Sie dran!

1. Textgenerierungsdienst:

@Service
public class LLMService {
    private final WebClient webClient;
    private static final Logger logger = LoggerFactory.getLogger(LLMService.class);

    // Constructor to initialize WebClient with Hugging Face API URL and API key
    public LLMService(@Value("${huggingface.text.api.url}") String apiUrl,
                      @Value("${huggingface.api.key}") String apiKey) {
        this.webClient = WebClient.builder()
                .baseUrl(apiUrl) // Set the base URL for the API
                .defaultHeader("Authorization", "Bearer " + apiKey) // Add API key to the header
                .build();
    }

    // Method to generate text using Hugging Face's Inference API
    public Mono<String> generateText(String prompt) {
        // Validate the input prompt
        if (prompt == null || prompt.trim().isEmpty()) {
            return Mono.error(new IllegalArgumentException("Prompt must not be null or empty"));
        }

        // Create the request body with the prompt
        Map<String, String> body = Collections.singletonMap("inputs", prompt);

        // Make a POST request to the Hugging Face API
        return webClient.post()
                .bodyValue(body) 
                .retrieve() 
                .bodyToMono(String.class) 
                .doOnSuccess(response -> logger.info("Response received: {}", response)) // Log successful responses
                .doOnError(error -> logger.error("Error during API call", error)) // Log errors
                .retryWhen(Retry.backoff(3, Duration.ofMillis(500))) // Retry on failure with exponential backoff
                .timeout(Duration.ofSeconds(5)) // Set a timeout for the API call
                .onErrorResume(error -> Mono.just("Fallback response due to error: " + error.getMessage())); // Provide a fallback response on error
    }
}

2. Bilderzeugungsdienst:

@Service
public class ImageGenerationService {

    private static final Logger logger = LoggerFactory.getLogger(ImageGenerationService.class);
    private final WebClient webClient;

    public ImageGenerationService(@Value("${huggingface.image.api.url}") String apiUrl,
                                  @Value("${huggingface.api.key}") String apiKey) {
        this.webClient = WebClient.builder()
                .baseUrl(apiUrl)
                .defaultHeader("Authorization", "Bearer " + apiKey)
                .build();
    }

    public Mono<byte[]> generateImage(String prompt) {
        if (prompt == null || prompt.trim().isEmpty()) {
            return Mono.error(new IllegalArgumentException("Prompt must not be null or empty"));
        }

        Map<String, String> body = Collections.singletonMap("inputs", prompt);

        return webClient.post()
                .bodyValue(body)
                .retrieve()
                .bodyToMono(byte[].class) / Convert the response to a Mono<byte[]> (image bytes)
                .timeout(Duration.ofSeconds(10)) // Timeout after 10 seconds
                .retryWhen(Retry.backoff(3, Duration.ofMillis(500))) // Retry logic
                .doOnSuccess(response -> logger.info("Image generated successfully for prompt: {}", prompt))
                .doOnError(error -> logger.error("Error generating image for prompt: {}", prompt, error))
                .onErrorResume(WebClientResponseException.class, ex -> {
                    logger.error("HTTP error during image generation: {}", ex.getMessage(), ex);
                    return Mono.error(new RuntimeException("Error generating image: " + ex.getMessage()));
                })
                .onErrorResume(TimeoutException.class, ex -> {
                    logger.error("Timeout while generating image for prompt: {}", prompt);
                    return Mono.error(new RuntimeException("Request timed out"));
                });
    }
}

Beispielaufforderungen und ihre Ergebnisse: ?

1. Textbasierter Endpunkt:

2. Bildbasierter Endpunkt:

? Entdecken Sie das Projekt

Bereit zum Eintauchen? Schauen Sie sich das GitHub-Repository von QuickAI an, um den vollst?ndigen Code zu sehen und mitzumachen. Wenn Sie es nützlich finden, geben Sie ihm ein ?.

Bonus?

M?chten Sie dieses Projekt weiter vorantreiben?

• Ich habe die Swagger-Benutzeroberfl?che für die API-Dokumentation konfiguriert, die Ihnen beim Erstellen einer Frontend-App hilft.
• Erstellen Sie eine einfache Frontend-App mit Ihrem bevorzugten Frontend-Framework (wie React, Angular oder einfach nur HTML/CSS/Vanilla JS).

? Herzlichen Glückwunsch, Sie haben es bis hierher geschafft.

Jetzt wissen Sie, wie man Hugging Face verwendet?:

1. Um KI-Modelle schnell in Ihren Anwendungen zu verwenden.
2. Text generieren: Erstellen Sie kreative Inhalte aus Eingabeaufforderungen.
3. Bilder generieren: Verwandeln Sie Textbeschreibungen in Bilder.

? Lass uns verbinden!

M?chten Sie zusammenarbeiten oder haben Sie Vorschl?ge? Finden Sie mich auf LinkedIn, Portfolio. Schauen Sie sich auch andere meiner Projekte hier auf GitHub an.

Haben Sie eine Frage oder einen Vorschlag, hinterlassen Sie bitte hier unten einen Kommentar. Ich werde gerne darauf eingehen.

Viel Spa? beim Programmieren! ?

Das obige ist der detaillierte Inhalt vonMühelose Integration von KI-Modellen: Erstellen und Bewerten von KI-Modellen (Spring Boot und Hugging Face). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!