Wie kann ich eine Integralberechnung programmieren?

Ich soll von einer Funktion das Integral berechnen. Ich habe es so gemacht:

def funktion(x):
    return x**3 - 2 * x**2 + x - 3

print(funktion(0)) # Beispielberechnung von Funktionswert an Stelle x = 0

def integrate(start, end, step):
    fläche = 0

    while start < end:
        fläche += funktion(start) * step
        start += step

    return fläche

def adaptive_anpassung(toleranz):
    tolernaz = 0.01
    ergebnis = integrate(start, end, step)
    neues_ergebnis = integrate(start, end, step / 2)
    while abs(ergebnis - neues_ergebnis) > tolernaz:
         neues_ergebnis = integrate(start, end, step / 2)

#Beispielaufruf
start = 0
end = 2
step = 0.001
print(integrate(start, end, step))

Zusätzlich soll ich eine Funktion implementieren, die schrittweise den Wert step verkleinert, bis die Veränderungen des Ergebnisses der integrate-Funktion kleiner als 0.01 ist. Ich habe die Funktion adaptive_anpassung genannt, aber irgendwie will es nicht. Kann mir jemand helfen?

1 Antwort

Vom Fragesteller als hilfreich ausgezeichnet

KarlRanseierIII

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

programmieren, Informatik, Programmiersprache

14.12.2023, 19:38

Ich würde ja ergebnis auch mal aktualisieren.

while abs (ergebnis-neues_ergebnis)>tolernaz:
         ergebnis=neues_ergebnis
         neues_ergebnis=integrate(start,end,step/2)

Du willst ja sichergehen, daß das Delta der Integrationsergerbnisse unter den Grenzwert fällt, um zuzusichern, daß das numerische Ergebnis ausreichend genau ist.

Und natürlich müßtest Du die Funktion dann auch mal aufrufen.

kabik334

Fragesteller

14.12.2023, 20:53

das mit dem ergebnis aktualisieren versteh ich nicht waruk ergebis=neues ergebnis?

KarlRanseierIII

15.12.2023, 04:40

@kabik334

Vielleicht verstehst Du es so:

>>> print("\n".join(f'{1/x:.4f}: {integrate(1,20,1/x):.4f}' for x in range(1,25)))
1.0000: 31293.0000
0.5000: 33027.9375
0.3333: 36022.2963
0.2500: 33912.9219
0.2000: 35534.7200
0.1667: 34210.5116
0.1429: 35326.7755
0.1250: 34359.7930
0.1111: 35211.5144
0.1000: 34449.5175
0.0909: 34482.1736
0.0833: 35110.8154
0.0769: 35087.5976
0.0714: 34552.2028
0.0667: 35050.4652
0.0625: 34584.3232
0.0588: 35022.0830
0.0556: 34609.3161
0.0526: 34619.8421
0.0500: 34629.3169
0.0476: 34981.5571
0.0455: 34645.6854
0.0435: 34966.5860
0.0417: 34659.3288

Erkennst Du das Grundproblem?

Ich zitiere derweil aus der Frage:

Zusätzlich soll ich eine Funktion implementieren, die schrittweise den Wert step verkleinert, bis die Veränderungen des Ergebnisses der integrate-Funktion kleiner als 0.01 ist.

Der Knackpunkt ist hier die Veränderung.

KarlRanseierIII

15.12.2023, 04:54

@KarlRanseierIII

Und so könnte dasdann zum Beispiel aussehen:

def adaptive_anpassung(start,end,step,epsilon):
    ergebnis = integrate(start, end, step)
    neues_ergebnis = integrate(start, end, step / 2)
    while abs(ergebnis - neues_ergebnis) > epsilon:
       step=step/2
       ergebnis=neues_ergebnis
       neues_ergebnis = integrate(start, end, step / 2)
    return neues_ergebnis

Das ließe sich auch schöner formulieren, aber seis drum.

kabik334

Fragesteller

16.12.2023, 18:19

@KarlRanseierIII

ich glaube net das ich versthe was du meinst

Franz1957

16.12.2023, 18:35

@KarlRanseierIII

Dann ist da noch ein weiteres Hindernis: Mit einem so großen Wert wie 0.01 für epsilon bzw. toleranz ist abs(ergebnis - neues_ergebnis) von Beginn an nicht > sondern < als epsilon. Die Schleife beginnt darum gar nicht erst zu laufen und die adaptive Anpassung findet nicht statt.

KarlRanseierIII

17.12.2023, 00:47

@Franz1957

Wenn das Delta eben kleiner als der angegebene Wert ist, dann klar, wird direkt das Ergebnis des halben Steppings genommen, weil das Stepping offensichtlich klein genug war.

Ein anderes Grundproblem bei der Nutzugn von Floats ist die nicht homogene Präzision über den Zahlenbereich - sidn meine Werte groß genug, dann kann es passieren, daß die Differenz nie unter die Schranke fällt. Insofern wäre es vielleicht schlauer sowas wie Decimal zu nutzen.

kabik334

Fragesteller

20.12.2023, 17:06

@KarlRanseierIII

eins verstehe ich immer noch nicht warum diese Zeile:step=step/2

in meinen letzen beiden zeilen sage ich ja ergbnis ist jetzt neues ergebnis das wiederum ist die funktion integrate wo aber schon die step halbierung mit beinhaletet ist.Wenn dort doch bereits step jedes mal halbiert wieder wieso brauch ich das extra noch mal in der zeile step=step/2

KarlRanseierIII

20.12.2023, 18:24

@kabik334

Geh es doch einfach mal Schritt für Schritt durch. Bedenke, daß ein step/2 beim Aufruf sich nicht auf step selbst auswirkt.

Ähnliche Fragen

flächenberechnung programmieren?

ich soll eine funtkion schreiben die die Fläche einer funtkion mittelwertmethode berechent bei der man immer in der Mitte des aktuellen Abschnitts den Y-Wert berechnen. Mein Ansatz:

def area(start, ende, step):
    flache = 0
    mid = (start + step) / 2
    while mid < ende:
        flache+=abs(step*f(mid))
        mid+=step
    return flache

es kommt aber immer ein falsches ergnis wenn ich einen bsp aufruf mache

...zur Frage

C integral berechnung implementierung?

Alles passt außer die funktion adaptanpassung ich versthe nicht wo der Fehler ist . Die funktion ist da um das integral geanuer zu machen bis die veränderung des Ergebnises nicht mehr um 0.01 abweicht. In Python hab ich es eignetlich genau so gemacht und es hat geklappt. Ich weiß das Python und C ganz andere Prog.Sprachen sind ,dennoch verstehe ich nicht warum es nicht will

#include <stdio.h>
#include <math.h>

// Aufgabe 1
float func(float x){
    return x*x*x-2*x*x+x-3;

}

float integrate(float start, float end, float step){
    float flaeche=0;
    while (start<end){
        flaeche+=step* func(start);
        start=start+step;
    }
    return fabs(flaeche);
}


void adaptanspassung(float toleranz){
    toleranz=0.01;
    float ergebnis= integrate(float start,float end,float step);
    float neues_ergnis= integrate(float start,float end,float step/2);
    while ((ergebnis - neues_ergnis) > toleranz){
        ergebnis=neues_ergnis;
        neues_ergnis=integrate(float start,float end,float step/2);

}


int main() {
    printf("%f\n", func(0)) ;
    adaptanspassung(0.01);
    printf("%f\n", integrate(0,2,0.02));

    return 0;
}

...zur Frage

Iterativen Code in Rekursiven umwandeln?

Hi zusammen,

Ich soll einen Code erfinden, der das tägliche Gehalt (angefangen bei 1 Cent) jeden gearbeiteten Tag verdoppelt und die Funktion soll nur einen Parameter erhalten.

Den iterative habe ich bereits:

def print_gehalt_iterativ(tage):

a = 1

while tage > 0:

a = a + a

tage = tage - 1

print(a)

Ich komme leider nicht zur rekursiven Variante....

def print_gehalt_rekursiv(tage):

a = 1

if tage == 0:

return a

if tage > 0:

a = a + a

return a

else:

return print_gehalt_rekursiv(tage - 1)

kann mir einer helfen bitte? :) Danke, Lucia

...zur Frage

Kann sich eine Funktion selbst rufen, unendlich oft?

Wenn ich die funktion in der funktion schreibe kann sie sich dann unendlich oft selbst rufen?

Z.b.

def same():

print("Gott Wtf")

same()

...zur Frage

Mein Python Code funktioniert nicht?

Guten Abend erst einmal,

ich habe versucht mittels Python ein Mau Mau spiel zu erstellen, aber wenn ich es ausprobieren will, zeigt mir das Programm mitten im code " invalid Syntax " an.

Kann einer von euch mal bitte drüber schauen und mir sagen, was fehlt?

Hier ist der Code (,was mir als Fehler angezeigt wurde habe ich markiert( es ist das deck.shuffel ())).

import random

class Card:

def __init__(self, value, suit):

self.value = value

self.suit = suit

def __repr__(self):

return f"{self.value} of {self.suit}"

class Deck:

suits = ["Hearts", "Diamonds", "Spades", "Clubs"]

values = ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"]

def __init__(self):

self.cards = [Card(value, suit) for suit in self.suits for value in self.values]

def shuffle(self):

random.shuffle(self.cards)

def deal(self):

return self.cards.pop()

class Player:

def __init__(self, name):

self.name = name

self.hand = []

def draw(self, deck):

self.hand.append(deck.deal())

def play_card(self, card):

self.hand.remove(card)

class AIPlayer(Player):

def choose_card(self, top_card):

for card in self.hand:

if card.value == top_card.value or card.suit == top_card.suit:

return card

return self.hand[0]

def play_game():

deck = Deck()

... deck.shuffle()

...

... player = Player("Player")

... ai = AIPlayer("AI")

...

... for i in range(7):

... player.draw(deck)

... ai.draw(deck)

...

... top_card = deck.deal()

...

... while len(player.hand) > 0 and len(ai.hand) > 0:

... print(f"Top card: {top_card}")

... print(f"{player.name}'s hand: {player.hand}")

...

... chosen_card = player.play_card(player.hand[int(input("Choose a card to play (index): "))])

... if chosen_card.value == top_card.value or chosen_card.suit == top_card.suit:

... top_card = chosen_card

... else:

... player.draw(deck)

... print(f"{player.name} drew a card.")

...

... if len(ai.hand) > 0:

... chosen_card = ai.choose_card(top_card)

... print(f"{ai.name} played {chosen_card}.")

... if chosen_card.value == top_card.value or chosen_card.suit == top_card.suit:

... top_card = chosen_card

... else:

... ai.draw(deck)

... print(f"{ai.name} drew a card.")

...

... if len(player.hand) == 0:

... print(f"{player.name} wins!")

... else:

... print(f"{ai.name} wins!"

>>> [DEBUG ON]

>>> [DEBUG OFF]

...zur Frage

Warum werden in diesem Code Klassen verwendet?

Also was für einen Vorteil hat das?:

Der Code ist für ein Tic-Tac-Toe-Spiel

class Board():
    def __init__(self):
        self.state = [0, 0, 0, 0, 0, 0, 0, 0, 0]

    def make_turn(self, cell, player):
        if self.is_valid_turn(cell):
            self.state[cell] = player.symbol
            return True
        return False

    def is_valid_turn(self, cell):
        if self.state[cell] == 0:
            return True
        else:
            return False

    def check_win(self, player):
        s = player.symbol
        if self.state[0] == s and self.state[1] == s and self.state[2] == s:
            return True
        elif self.state[3] == s and self.state[4] == s and self.state[5] == s:
            return True
        elif self.state[6] == s and self.state[7] == s and self.state[8] == s:
            return True

        elif self.state[0] == s and self.state[3] == s and self.state[6] == s:
            return True
        elif self.state[1] == s and self.state[4] == s and self.state[7] == s:
            return True
        elif self.state[2] == s and self.state[5] == s and self.state[8] == s:
            return True

        elif self.state[0] == s and self.state[4] == s and self.state[8] == s:
            return True
        elif self.state[2] == s and self.state[4] == s and self.state[6] == s:
            return True

    def is_full(self):
        for i in self.state:
            if i == 0:
                return False
        return True

    def sign_to_printable(self, sign):
        if sign == 0:
            return " "
        elif sign == 1:
            return "X"
        else:
            return "O"

    def print_board(self):
        print(" " + self.sign_to_printable(self.state[0]) + " | " + self.sign_to_printable(self.state[1]) + " | " + self.sign_to_printable(self.state[2]) + " \n" +
              " " + self.sign_to_printable(self.state[3]) + " | " + self.sign_to_printable(self.state[4]) + " | " + self.sign_to_printable(self.state[5]) + " \n" +
              " " + self.sign_to_printable(self.state[6]) + " | " + self.sign_to_printable(self.state[7]) + " | " + self.sign_to_printable(self.state[8]) + " \n")


class Player:
    def __init__(self, symbol):
        self.symbol = symbol


if __name__ == '__main__':
    player_a = Player(1)
    player_b = Player(-1)
    board = Board()
    active_player = player_a
    while not board.is_full():
        board.print_board()
        try:
            cell = int(input("Where do you want to place your sign? [1-9]"))
        except ValueError:
            continue
        cell = cell - 1
        if cell < 0 or cell > 8:
            print("Please enter a number between 1 and 9")
            continue
        if not board.make_turn(cell, active_player):
            print("Invalid Move")
            continue

        if board.check_win(active_player):
            print("You wonnered! GW.")
            break

        if …

...zur Frage

Warum wird das Wake Word nicht erkannt?

Hallo,

ich programmiere momentan einen Sprachassistenten und bin gerade am Wake Word dran. Mein Code sieht so aus:

import pyttsx3
import re
import pyjokes
import speech_recognition as sr
from pyowm import OWM
import spotipy
from spotipy.oauth2 import SpotifyOAuth
import time
import random
import datetime
import pytz
from geopy.geocoders import Nominatim
from timezonefinder import TimezoneFinder
import sounddevice as sd
import pvporcupine
import openai

openai.api_key = 'sk-...'
model_id = "gpt-4"

engine = pyttsx3.init()


def recognize_speech(recognizer, source):
    print("Sage etwas...")
    audio = recognizer.listen(source, timeout=15)
    try:
        text = recognizer.recognize_google(audio, language="de-DE")
        print("Text: " + text)
        return text
    except sr.UnknownValueError:
        return "not_understood"
    except sr.RequestError as e:
        print(f"Fehler bei der Anfrage an die Google Web Speech API: {e}")
        return ""


def picovoice_listen():
    keyword_file_path = "C:\\Hey-Luna_de_windows_v3_0_0\\Hallo-Luna_de_windows_v3_0_0.ppn"
    sensitivities = [0.7]

    try:
        porcupine = pvporcupine.create(
            access_key='...',
            keyword_paths=['C:\\Hey-Luna_de_windows_v3_0_0\\Hallo-Luna_de_windows_v3_0_0.ppn'],
            model_path='C:\\Hey-Luna_de_windows_v3_0_0\\porcupine_params_de.pv'
        )

        sample_rate = porcupine.sample_rate
        print("Sample Rate:", sample_rate)

        pcm = record_audio(sample_rate=sample_rate, duration=3)
        keyword_index = porcupine.process(pcm)

        if keyword_index >= 0:
            print("Wake word detected!")
            porcupine.delete()
            return True
        else:
            print("Wake word not detected!")

    except pvporcupine.PorcupineError as e:
        print(f"Porcupine error: {e}")

    return False


def record_audio(sample_rate, duration):
    print("Aufnahme gestartet...")
    audio = sd.rec(int(sample_rate * duration), samplerate=sample_rate, channels=1, dtype='int16')
    sd.wait()
    print("Aufnahme beendet.")
    return audio.flatten()[:512]


def openai_request(prompt):
    response = openai.ChatCompletion.create(
        model=model_id,
        messages=prompt
    )

    api_usage = response['usage']
    print('Total Token consumed: {0}'.format(api_usage['total_tokens']))
    prompt.append({'role': response.choices[0].message.role, 'content': response.choices[0].message.content})
    return prompt


def speak(text):
    engine.say(text)
    engine.runAndWait()


def ausführen():
    recognizer = sr.Recognizer()

    while True:
        if picovoice_listen():
            with sr.Microphone() as source:
                q = recognize_speech(recognizer, source)
                print("Erkannter Text:", q)

                if q == "not_understood":
                    speak("Entschuldigung! Das habe ich nicht verstanden.")
                    continue

                elif "hallo" in q:
                    speak('Hallo! Womit kann ich dir behilflich sein?')
                    continue

                else:
                    prompt = [{'role': 'user', 'content': q}]
                    prompt = openai_request(prompt)
                    response = prompt[-1]['content']
                    speak(response)
                    return  # Programm beenden, nachdem die Antwort gesprochen wurde


if __name__ == '__main__':
    ausführen()

wenn ich nun aber das Programm ausführe und das Wake Word ("Hallo Luna") sage, kommt immer "Wake word not detected!" und dann wiederholt sich das ganze, egal wie oft ich das Wake word sage. Woran liegt das?

Freundliche Grüsse

...zur Frage

Wofür ist die return Funktion genau?

Hallo, ich lerne gerade Python und bin gerade zu den return Funktionen gekommen. Aber wofür ist die genau, ich weiß nur, dass wenn ich eine definierte Funktion wie diese: def mittelwert(x,y): ergebnis=(x+y)/2 als Ergebnis einfach nur "None" kriege, falls ich später die Funktion "mittelwert" verwenden möchte, etwa so: c=mittelwert(3,9) print(c) Wenn ich aber "return Ergebnis dran hänge: def mittelwert(x,y): ergebnis=(x+y)/2 return ergebnis Dann bekomme ich als Ergebniss 6. Warum ist das so? Die anderen Seiten im Internet verwirrten mich nur noch mehr. Danke schonmal, MRColourblock

...zur Frage

python function while schleifen Problem?

def test():
  x = None
  while x != "False" or "True":
    x = input("True or False: ")
  for i in x:
    print("It is ")
    print(x, end="")
test()

Wieso funktioniert dieser Code nicht, das Problem liegt darin das man nicht mehr aus der while Schleife raus kommt.

...zur Frage

Python Flächeninhalt eines Kreises berechnen?

Hallo, ich möchte den Flächeninhalt eines Kreises in Python angezeigt bekommen. Mein Code lautet:

import math

radius = 10

def calculate_circle(radius):
    flaeche = math.pi * radius ** 2
    return flaeche

Leider funktioniert der Code nicht.. Woran liegt das?

...zur Frage

Gradientenabstieg Python?

def function(x):
    return x**2
def ableitung_function(x):
    return 2*x


x = 20
epochen = 15
for i in range(epochen):
    ableitung = ableitung_function(x)
    print(":____:")
    print(ableitung)
    print(x)
    print(":____:")
    lernrate = 0.1
    x_new = x-(lernrate*ableitung)
    x = x_new

Ist mein Gradientenabstieg korrekt? Meiner Meinung nach liefert es gute Ergebnisse, aber wenn ich eine Funktion wie z.b. x^3 und die Ableitung 3*x^2 benutze läuft alles falsch und wo brauche ich meine Funktion 'function'?

...zur Frage

Python Pickle Vokabeltrainer?

Hallo,

ich will einen simplen Vokabeltrainer mit python programmieren. Um die Vokabeln die vom user eingeben werden zu speichern verwende ich pickle. Leider werden ohne Fehlermeldung keine Vokabeln in der von mir angelegten Datei gespeichert.

import random
import pickle



class Entry:
    def __init__(self, deutsch, englisch):
        self.deutsch = deutsch
        self.englisch = englisch


    def toString(self):
        return self.deutsch + " - " + self.englisch
        
eintraege = [Entry("hallo", "hello")]


def save():
    with open('vocabulary.pkl', 'wb') as voc_pkl:
        pickle.dump(eintraege, voc_pkl)


save()
 
with open('vocabulary.pkl', 'rb') as voc_pkl:
    eintraege = pickle.load(voc_pkl)



def eingabe():
    while True:
        deutsch = input("Deutsches Wort: ")
        if deutsch == "#fertig":
            return
        englisch = input("Englisches Wort: ")
        if englisch == "#fertig":
            return
        eintraege.append(Entry(deutsch, englisch))
        save()
        
def abfrage():
    while True:
        i = random.randint(0,len(eintraege)-1)
        englisch = input("Englische Übersetzung von " + eintraege[i].deutsch + ": ")
        if(englisch == "#fertig"):
            return
        if eintraege[i].englisch == englisch:
            print("korrekt!")
        else:
            print("leider falsch. Richtige Antwort: " + eintraege[i].englisch)
            
def printall():
    for eintrag in eintraege:
        print(eintrag.toString())
        
while True:
    befehl = input("Befehl: ")
    if befehl == "eingabe":
        eingabe()
    elif befehl == "abfrage":
        abfrage()
    elif befehl == "beenden":
        break
    elif befehl == "ausgabe":
        printall()
    else:
        print("keine bekannte Ausgabe. Tippe: eingabe, abfrage, ausgabe oder beenden.")

...zur Frage

Raspberry PI Flask-404 Not Found?

Hallo!

Ich habe das programmiert. Es wird jede Sekunde die Temperatur von der CPU ausgelesen. Jetzt möchte ich Flask einbauen, damit ich mit mehreren PC's darauf zugreifen kann. Aber es funktioniert nicht. Warum?

from flask import Flask, jsonify
import subprocess
import time
import os
from colorama import Fore, Style

app = Flask(__name__)

@app.route("/temp")
def get_cpu_temperature():
  try:
    result = subprocess.run(['vcgencmd', 'measure_temp'], capture_output=True, text=True, check=True)
    temperature_str = result.stdout.strip()
    temperature = float(temperature_str[5:-2]) # Extrahiere die Temperatur aus dem String
    return temperature
  except subprocess.CalledProcessError as e:
    print(f"Fehler beim Ausführen des Befehls: {e}")
    return None

def print_colored_temperature(temperature):
  if temperature is not None:
    if temperature > 49.9:
      print(f"{Fore.RED}Temperatur: {temperature}°C{Style.RESET_ALL}")
    else:
      print(f"Temperatur: {temperature}°C")
  else:
    print("Fehler beim Lesen der CPU-Temperatur.")

def main():
  try:
    while True:
      temperature = get_cpu_temperature()
      print_colored_temperature(temperature)
      time.sleep(1)
      os.system('clear')
  except KeyboardInterrupt:
    print("Programm wurde durch den Benutzer unterbrochen.")
  except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")
     
     


if __name__ == '__main__':
  app.run(host="0.0.0.0")

if __name__ == '__main__':
  main()
  import sys
  sys.exit(main(sys.argv))

...zur Frage

Warum Funktioniert mein Wake Word nicht?

Hallo,

ich programmiere gerade einen Sprachassistenten und bin gerade am Wake Word dran. Mein Code sieht so aus:

import openai
import pyttsx3
import re
import pyjokes
import speech_recognition as sr
from pyowm import OWM
import spotipy
from spotipy.oauth2 import SpotifyOAuth
import time
import random
import datetime
import pytz
from geopy.geocoders import Nominatim
from timezonefinder import TimezoneFinder
import sounddevice as sd
import pvporcupine

openai.api_key = 'sk-...'
model_id = "gpt-4"

engine = pyttsx3.init()

WAKE_WORD_MODEL_FILE_PATH = "C:\\Hey-Luna_de_windows_v3_0_0\\Hey-Luna_de_windows_v3_0_0.ppn"


def recognize_speech():
    recognizer = sr.Recognizer()

    while True:
        with sr.Microphone() as source:
            print("Sage etwas...")
            audio = recognizer.listen(source, timeout=15)

        try:
            text = recognizer.recognize_google(audio, language="de-DE")
            print("Text: " + text)
            return text
        except sr.UnknownValueError:
            return "not_understood"
        except sr.RequestError as e:
            print(f"Fehler bei der Anfrage an die Google Web Speech API: {e}")
            return ""


def record_audio(sample_rate, duration):
    print("Aufnahme gestartet...")
    audio = sd.rec(int(sample_rate * duration), samplerate=sample_rate, channels=1, dtype='int16')
    sd.wait()
    print("Aufnahme beendet.")
    return audio.flatten()


def picovoice_listen():
    keyword_file_path = "C:\\Hey-Luna_de_windows_v3_0_0\\Hey-Luna_de_windows_v3_0_0.ppn"
    sensitivities = [0.5]  # Adjust as needed

    try:
        handle = pvporcupine.create(
            keyword_paths=[keyword_file_path],
            sensitivities=sensitivities,
            access_key='...'
        )

        sample_rate = handle.sample_rate

        while True:
            pcm = record_audio(sample_rate=sample_rate, duration=15)
            keyword_index = handle.process(pcm)

            if keyword_index >= 0:
                print("Wake word detected!")
                break

    except pvporcupine.PorcupineError as e:
        print(f"Porcupine error: {e}")

    finally:
        if 'handle' in locals():
            handle.delete()


def openai_request(prompt):
    response = openai.ChatCompletion.create(
        model=model_id,
        messages=prompt
    )

    api_usage = response['usage']
    print('Total Token consumed: {0}'.format(api_usage['total_tokens']))
    prompt.append({'role': response.choices[0].message.role, 'content': response.choices[0].message.content})
    return prompt


def speak(text):
    engine.say(text)
    engine.runAndWait()


def ausführen():
    while True:
        picovoice_listen()

        q = recognize_speech()
        print("Erkannter Text:", q)

        if q == "not_understood":
            speak("Entschuldigung! Das habe ich nicht verstanden.")
            break

        elif not q:
            break

        elif "hallo" in q:
            speak('Hallo! Womit kann ich dir behilflich sein?')
            continue

        else:
            prompt = [{'role': 'user', 'content': q}]
            prompt = openai_request(prompt)
            response = prompt[-1]['content']
            speak(response)
            break


if __name__ == '__main__':
    ausführen()

wenn ich nun aber das Programm ausführe, kommt diese Meldung und ich muss das Wake Word nicht sagen, um meine Frage zu stellen, welche dann von z.B. OpenAI beantwortet wird:

C:\Users\User\PycharmProjects\voiceAssistant\venv\interpreter\Scripts\python.exe C:\Users\User\PycharmProjects\voiceAssistant\main.py

Porcupine error: Initialization failed:

[0] Keyword file (.ppn) and model file (.pv) should belong to the same language. File belongs to `de` while model file (.pv) belongs to `en`.

Sage etwas...

woran liegt das?

Freundliche Grüsse

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen