Schreibe den Code um, um einen 8-Bit-Festkommazahltyp zu verwenden und füge nach der linearen Schicht eine RELU-Nichtlinearität hinzu.
Hilf mir, HLS-Quellcode zu schreiben, um einen FPGA-Hardwarebeschleuniger für einen streamingbasierten linearen Schichtbeschleuniger zu erstellen. Bitte verwende die Vitis HLS-Bibliotheken, einschließlich `hls_math.h`, `hls_stream.h` und `ap_fixed.h`. Die Eingaben für den Kernel sind ein Stream für den Eingabevektor und zwei feste Arrays für die Gewichte und den Bias. Alles verwendet Festkommazahltypen von `ap_fixed<32,10>`. Natürlich, hier ist ein Beispielcode für einen FPGA-Hardwarebeschleuniger für einen streamingbasierten linearen Schichtbeschleuniger unter Verwendung der Vitis HLS-Bibliotheken
```
#include "hls_math.h"
#include "hls_stream.h"
#include "ap_fixed.h"

// Definiere die Datentypen
typedef ap_fixed<32,10> fixed_type;
typedef hls::stream<fixed_type> stream_type;

// Definiere die Funktion für die lineare Schicht
void linear_layer(stream_type& input_stream, fixed_type weight[], fixed_type bias[], stream_type& output_stream) {
    // Setze die Anzahl der Eingabe- und Ausgabewerte
    const int N = 1024;

    // Führe die Berechnung der linearen Schicht durch
    for(int i = 0; i < N; i++) {
        fixed_type input_value = input_stream.read();
        fixed_type weighted_sum = 0;
        for(int j = 0; j < N; j++) {
            weighted_sum += input_value * weight[i * N + j];
        }
        fixed_type output_value = hls::tanh(weighted_sum + bias[i]);
        output_stream.write(output_value);
    }
}

// Funktion auf oberster Ebene für den Beschleuniger
void linear_accelerator(stream_type& input_stream, fixed_type weight[], fixed_type bias[], stream_type& output_stream) {
    #pragma HLS INTERFACE axis port=input_stream
    #pragma HLS INTERFACE axis port=output_stream
    #pragma HLS INTERFACE m_axi port=weight offset=slave bundle=gmem
    #pragma HLS INTERFACE m_axi port=bias offset=slave bundle=gmem

    // Rufe die Funktion für die lineare Schicht auf
    linear_layer(input_stream, weight, bias, output_stream);```
Hier ist der modifizierte Code, der einen 8-Bit-Festkommazahltyp verwendet und eine RELU-Nichtlinearität hinzufügt:

```c
#include "hls_math.h"
#include "hls_stream.h"
#include "ap_fixed.h"

// Definiere die Datentypen
typedef ap_fixed<8,2> fixed_type;
typedef hls::stream<fixed_type> stream_type;

// Definiere die Funktion für die lineare Schicht
void linear_layer(stream_type& input_stream, fixed_type weight[], fixed_type bias[], stream_type& output_stream) {
    // Setze die Anzahl der Eingabe- und Ausgabewerte
    const int N = 1024;

    // Führe die Berechnung der linearen Schicht durch
    for(int i = 0; i < N; i++) {
        fixed_type input_value = input_stream.read();
        fixed_type weighted_sum = 0;
        for(int j = 0; j < N; j++) {
            weighted_sum += input_value * weight[i * N + j];
        }
        fixed_type output_value = weighted_sum + bias[i];
        output_stream.write(output_value);
    }
}

// Definiere die RELU-Funktion
void relu(stream_type& input_stream, stream_type& output_stream) {
    const int N = 1024;
    for(int i = 0; i < N; i++) {
        fixed_type input_value = input_stream.read();
        fixed_type output_value = input_value > 0 ? input_value : 0;
        output_stream.write(output_value);
    }
}

// Funktion auf oberster Ebene für den Beschleuniger
void linear_accelerator(stream_type& input_stream, fixed_type weight[], fixed_type bias[], stream_type& output_stream) {
    #pragma HLS INTERFACE axis port=input_stream
    #pragma HLS INTERFACE axis port=output_stream
    #pragma HLS INTERFACE m_axi port=weight offset=slave bundle=gmem
    #pragma HLS INTERFACE m_axi port=bias offset=slave bundle=gmem

    // Erstelle Zwischenstreams
    stream_type linear_output_stream;
    stream_type relu_output_stream;

    // Rufe die Funktion für die lineare Schicht auf
    linear_layer(input_stream, weight, bias, linear_output_stream);

    // Rufe die RELU-Funktion auf
    relu(linear_output_stream, relu_output_stream);

    // Schreibe die Ausgabe in den Ausgabestream
    const int N = 1024;
    for(int i = 0; i < N; i++) {
        fixed_type output_value = relu_output_stream.read();
        output_stream.write(output_value);
    }
}
```

In diesem modifizierten Code definieren wir den Festkommazahltyp als `ap_fixed<8,2>`, was bedeutet, dass er insgesamt 8 Bits hat, wobei 2 dieser Bits für den Bruchteilsteil reserviert sind. Dann definieren wir die RELU-Funktion, die die Ausgabe der linearen Schicht nimmt und die RELU-Nichtlinearität anwendet (d.h. wenn der Eingabewert kleiner als 0 ist, wird die Ausgabe auf 0 gesetzt, sonst bleibt sie unverändert). Schließlich rufen wir in der Funktion auf oberster Ebene die Funktion für die lineare Schicht auf, dann die RELU-Funktion und schreiben die endgültige Ausgabe in den Ausgabestream.