| import numpy as np | |
| import whisper | |
| from torch import nn | |
| from torch import Tensor | |
| class PyAI: | |
| def __init__(self, useGPU: bool): | |
| self.GPU = useGPU | |
| class Algorithms: | |
| def KNN(x, y, returnValues = 0): | |
| distances = [] | |
| for axisX, axisY in zip(x, y): | |
| distance = axisX - axisY | |
| absDistance = np.absolute(distance) | |
| distances.append(absDistance) | |
| sortedDistances = [] | |
| checkDistance = min(distances, key = lambda x:np.absolute(x-i)) | |
| sortedDistances.append(checkDistance) | |
| distances.remove(checkDistance) | |
| if returnValues == 0: | |
| return sortedDistances[0] | |
| else: | |
| return sortedDistances[0:returnValues-1] | |
| def RNN(w, u, b, x): | |
| yt = 0 | |
| ht = 1 / 1 (w * x + u * yt ** -1 + b) ** -1 | |
| yt = 1 / 1 (w * ht + b) ** -1 | |
| return yt | |
| def ReLU(self, x: list, *y: list, **u: list): | |
| X, Y, U = [Tensor(x2) for x2 in x], [Tensor(y2) for y2 in y], [Tensor(u2) for u2 in u] | |
| if self.GPU: | |
| relu = nn.ReLU().to("cuda") | |
| else: | |
| relu = nn.ReLU().to("cpu") | |
| newX, newY, newU = [relu(x) for x in X], [relu(y) for y in Y], [relu(u) for u in U] | |
| if newU is not None: | |
| return newX, newY, newU | |
| elif newY is not None: | |
| return newX, newY | |
| else: | |
| return newX | |
| class Audio: | |
| def __init__(self, audio: str): | |
| self.model = whisper.load_model("base") | |
| self.audio = audio | |
| def generateTextFromAudio(self) -> str: | |
| aud = whisper.load_audio(self.audio) | |
| aud = whisper.pad_or_trim(aud) | |
| self.mel = whisper.log_mel_spectrogram(aud).to(self.model.device) | |
| self.model.detect_language(self.mel) | |
| options = whisper.DecodingOptions() | |
| result = whisper.decode(self.model, self.mel, options) | |
| return result.text | |
| def translateText(self, text: str, dataSet: str) -> str: | |
| with open(dataSet, "r") as d: | |
| data = d.read() | |
| translation = text.translate(data) | |
| return translation | |
| def getLang(self): | |
| i, lang = self.model.detect_language(self.mel) | |
| return max(lang, key=lang.get) | |
| class NLP: | |
| def __init__(self, text: str): | |
| self.text = text | |
| self.sentences = text.split(".") | |
| self.words = text.split(" ") | |
| self._past = ["was", "had", "did"] | |
| self._present = ["is", "has"] | |
| self._future = ["will", "shall"] | |
| def setTokensTo(self, letters: bool, *words: bool, **sentences: bool): | |
| self.tokens = [] | |
| if letters: | |
| tokens = iter(self.text) | |
| for t in tokens: | |
| self.tokens.append(t) | |
| elif words: | |
| for t in self.words: | |
| self.tokens.append(t) | |
| elif sentences: | |
| for t in self.sentences: | |
| self.tokens.append(t) | |
| else: | |
| self.tokens.append("ERROR") | |
| def getTense(self): | |
| self.past = False | |
| self.present = False | |
| self.future = False | |
| if self.sentences in self._past: | |
| self.past = True | |
| elif self.sentences in self._present: | |
| self.present = True | |
| elif self.sentences in self._future: | |
| self.future = True | |
| else: | |
| return "ERROR - Tense :: Not Enough Data" | |
| return self.past, self.present, self.future | |
| def getWords(self): | |
| return self.words | |
| def getSentences(self): | |
| return self.sentences | |
| def getTokens(self): | |
| return self.tokens |