Bild vom Autor

# Einführung

Täglich zeichnen Kundendienstzentren Tausende von Gesprächen auf. In diesen Audiodateien verbergen sich Goldminen an Informationen. Sind die Kunden zufrieden? Welche Probleme werden am häufigsten erwähnt? Wie verändern sich Emotionen während eines Anrufs?
Die manuelle Analyse dieser Aufzeichnungen ist eine Herausforderung. Mit moderner künstlicher Intelligenz (KI) können wir jedoch Anrufe automatisch transkribieren, Emotionen erkennen und wiederkehrende Themen extrahieren – alles offline und mit Open-Supply-Instruments.

In diesem Artikel werde ich Sie durch ein komplettes Projekt zur Analyse der Kundenstimmung führen. Sie erfahren, wie Sie:

• Audiodateien in Textual content umwandeln mit Flüstern
• Erkennen von Gefühlen (positiv, negativ, impartial) und Emotionen (Frustration, Zufriedenheit, Dringlichkeit)
• Themen automatisch extrahieren mit BERThema
• Ergebnisse in einem interaktiven Dashboard anzeigen

Das Beste daran ist, dass alles lokal läuft. Ihre sensiblen Kundendaten verlassen niemals Ihr Gerät.

Abb. 1: Dashboard-Übersicht mit Stimmungsanzeige, Emotionsradar und Themenverteilung

# Verstehen, warum lokale KI für Kundendaten wichtig ist

Cloudbasierte KI-Dienste wie OpenAIs API sind leistungsstark, bringen jedoch Bedenken mit sich, beispielsweise hinsichtlich des Datenschutzes, da Kundenanrufe oft persönliche Informationen enthalten; hohe Kosten, bei denen Sie einen Preis professional API-Aufruf zahlen, der sich bei großen Volumina schnell summiert; und Abhängigkeit von Web-Gebührenbeschränkungen. Durch die lokale Ausführung ist es einfacher, die Anforderungen an die Datenresidenz zu erfüllen.

Dieses lokale KI-Sprach-zu-Textual content-Tutorial behält alles auf Ihrer {Hardware}. Modelle werden einmal heruntergeladen und laufen dauerhaft offline.

Abb. 2: Übersicht über die Systemarchitektur, die zeigt, wie jede Komponente eine Aufgabe intestine bewältigt. Durch diesen modularen Aufbau ist das System leicht zu verstehen, zu testen und zu erweitern

// Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

• Python 3.9+ ist auf Ihrem Pc installiert.
• Das hättest du tun sollen FFmpeg für die Audioverarbeitung installiert.
• Sie sollten über grundlegende Kenntnisse mit Python und den Konzepten des maschinellen Lernens verfügen.
• Für KI-Modelle benötigen Sie etwa 2 GB Speicherplatz.

// Einrichten Ihres Projekts

Klonen Sie das Repository und richten Sie Ihre Umgebung ein:

git clone https://github.com/zenUnicorn/Buyer-Sentiment-analyzer.git

Erstellen Sie eine virtuelle Umgebung:

Aktivieren (Home windows):

Aktivieren (Mac/Linux):

Abhängigkeiten installieren:

pip set up -r necessities.txt

Beim ersten Durchlauf werden KI-Modelle heruntergeladen (~1,5 GB insgesamt). Danach funktioniert alles offline.

Abb. 3: Terminal zeigt erfolgreiche Set up

# Audio mit Whisper transkribieren

Im Kundenstimmungsanalysator besteht der erste Schritt darin, gesprochene Wörter aus Anrufaufzeichnungen in Textual content umzuwandeln. Dies geschieht mit Whisper, einem von entwickelten automatischen Spracherkennungssystem (ASR). OpenAI. Schauen wir uns an, wie es funktioniert, warum es eine gute Wahl ist und wie wir es im Projekt verwenden.

Whisper ist ein Transformer-basiertes Encoder-Decoder-Modell, das auf 680.000 Stunden mehrsprachigem Audio trainiert wurde. Wenn Sie ihm eine Audiodatei zuführen, geschieht Folgendes:

• Neuabtastung des Audiosignals auf 16-kHz-Mono
• Erzeugt ein Mel-Spektrogramm – eine visuelle Darstellung der Frequenzen im Zeitverlauf – das als Foto des Klangs dient
• Teilt das Spektrogramm in 30-Sekunden-Fenster auf
• Leitet jedes Fenster durch einen Encoder, der versteckte Darstellungen erstellt
• Übersetzt diese Darstellungen Wort für Wort (oder Unterwort) in Textual content-Tokens

Stellen Sie sich das Mel-Spektrogramm als die Artwork und Weise vor, wie Maschinen Geräusche „sehen“. Die x-Achse stellt die Zeit dar, die y-Achse stellt die Frequenz dar und die Farbintensität zeigt die Lautstärke. Das Ergebnis ist ein hochpräzises Transkript, auch bei Hintergrundgeräuschen oder Akzenten.

Code-Implementierung

Hier ist die Kernlogik der Transkription:

import whisper

class AudioTranscriber:
    def __init__(self, model_size="base"):
        self.mannequin = whisper.load_model(model_size)
   
    def transcribe_audio(self, audio_path):
        outcome = self.mannequin.transcribe(
            str(audio_path),
            word_timestamps=True,
            condition_on_previous_text=True
        )
        return {
            "textual content": outcome("textual content"),
            "segments": outcome("segments"),
            "language": outcome("language")
        }

Der model_size Der Parameter steuert die Genauigkeit im Verhältnis zur Geschwindigkeit.

Für die meisten Anwendungsfälle gilt: base oder small bietet die beste Steadiness.

Abb. 4: Transkriptionsausgabe mit zeitgestempelten Segmenten

# Stimmungsanalyse mit Transformern

Mit extrahiertem Textual content analysieren wir die Stimmung mithilfe von Umarmende Gesichtstransformatoren. Wir verwenden CardiffNLPs RoBERTa Modell, trainiert auf Social-Media-Textual content, das sich perfekt für gesprächige Kundenanrufe eignet.

// Vergleich von Gefühl und Emotion

Die Stimmungsanalyse klassifiziert Texte als positiv, impartial oder negativ. Wir verwenden ein fein abgestimmtes RoBERTa-Modell, weil es den Kontext besser versteht als ein einfaches Key phrase-Matching.

Das Transkript wird tokenisiert und durch einen Transformer geleitet. Die letzte Ebene verwendet eine Softmax-Aktivierung, die Wahrscheinlichkeiten ausgibt, die sich auf 1 summieren. Wenn beispielsweise positiv 0,85, impartial 0,10 und negativ 0,05 ist, ist die Gesamtstimmung positiv.

• Gefühl: Gesamtpolarität (positiv, negativ oder impartial) zur Beantwortung der Frage: „Ist das intestine oder schlecht?“
• Emotion: Spezifische Gefühle (Wut, Freude, Angst) als Antwort auf die Frage: „Was genau fühlen sie?“

Wir erkennen beides für einen vollständigen Einblick.

// Code-Implementierung für die Stimmungsanalyse

from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch.nn.purposeful as F

class SentimentAnalyzer:
    def __init__(self):
        model_name = "cardiffnlp/twitter-roberta-base-sentiment-latest"
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.mannequin = AutoModelForSequenceClassification.from_pretrained(model_name)
   
    def analyze(self, textual content):
        inputs = self.tokenizer(textual content, return_tensors="pt", truncation=True)
        outputs = self.mannequin(**inputs)
        possibilities = F.softmax(outputs.logits, dim=1)
       
        labels = ("adverse", "impartial", "constructive")
        scores = {label: float(prob) for label, prob in zip(labels, possibilities(0))}
       
        return {
            "label": max(scores, key=scores.get),
            "scores": scores,
            "compound": scores("constructive") - scores("adverse")
        }

Der compound Die Bewertung reicht von -1 (sehr negativ) bis +1 (sehr positiv), sodass sich Stimmungstrends im Zeitverlauf leicht verfolgen lassen.

// Warum einfache Lexikonmethoden vermeiden?

Traditionelle Ansätze wie VADER Zähle constructive und adverse Wörter. Allerdings fehlt ihnen oft der Kontext:

• „Das ist nicht intestine.“ Lexicon sieht „intestine“ als positiv an.
• Ein Transformator versteht Negation („nicht“) als negativ.

Transformatoren verstehen Beziehungen zwischen Wörtern und machen sie so für reale Texte weitaus genauer.

# Extrahieren von Themen mit BERTopic

Es ist nützlich, die Stimmung zu kennen, aber worüber reden Kunden? BERThema erkennt automatisch Themen im Textual content, ohne dass Sie sie vorab definieren müssen.

// So funktioniert BERTopic

• Einbettungen: Konvertieren Sie jedes Transkript mithilfe von in einen Vektor Satztransformatoren
• Dimensionsreduzierung: UMAP komprimiert diese Vektoren in einen niedrigdimensionalen Raum
• Clustering: HDBSCAN gruppiert ähnliche Transkripte
• Themenvertretung: Extrahieren Sie für jeden Cluster die relevantesten Wörter mit c-TF-IDF

Das Ergebnis ist eine Reihe von Themen wie „Abrechnungsprobleme“, „technischer Assist“ oder „Produktfeedback“. Im Gegensatz zu älteren Methoden wie Latente Dirichlet-Zuordnung (LDA)BERTopic versteht semantische Bedeutung. „Versandverzögerung“ und „verspätete Lieferung“ kommen zusammen, weil sie dieselbe Bedeutung haben.

Code-Implementierung

Aus matters.py:

from bertopic import BERTopic

class TopicExtractor:
    def __init__(self):
        self.mannequin = BERTopic(
            embedding_model="all-MiniLM-L6-v2",
            min_topic_size=2,
            verbose=True
        )
   
    def extract_topics(self, paperwork):
        matters, possibilities = self.mannequin.fit_transform(paperwork)
       
        topic_info = self.mannequin.get_topic_info()
        topic_keywords = {
            topic_id: self.mannequin.get_topic(topic_id)(:5)
            for topic_id in set(matters) if topic_id != -1
        }
       
        return {
            "assignments": matters,
            "key phrases": topic_keywords,
            "distribution": topic_info
        }

Notiz: Für die Themenextraktion sind mehrere Dokumente (mindestens 5–10) erforderlich, um sinnvolle Muster zu finden. Einzelne Anrufe werden mithilfe des angepassten Modells analysiert.

Abb. 5: Balkendiagramm zur Themenverteilung mit den Kategorien Abrechnung, Versand und technischer Assist

# Erstellen eines interaktiven Dashboards mit Streamlit

Rohdaten sind schwer zu verarbeiten. Wir haben eine gebaut Streamlit Armaturenbrett (app.py), mit dem Geschäftsanwender Ergebnisse erkunden können. Streamlit verwandelt Python-Skripte mit minimalem Code in Webanwendungen. Unser Dashboard bietet:

• Add-Schnittstelle für Audiodateien
• Echtzeitverarbeitung mit Fortschrittsanzeigen
• Interaktive Visualisierungen mit Plotly
• Drilldown-Funktion zur Untersuchung einzelner Anrufe

// Code-Implementierung für die Dashboard-Struktur

import streamlit as st

def principal():
    st.title("Buyer Sentiment Analyzer")
   
    uploaded_files = st.file_uploader(
        "Add Audio Information",
        sort=("mp3", "wav"),
        accept_multiple_files=True
    )
   
    if uploaded_files and st.button("Analyze"):
        with st.spinner("Processing..."):
            outcomes = pipeline.process_batch(uploaded_files)
       
        # Show outcomes
        col1, col2 = st.columns(2)
        with col1:
            st.plotly_chart(create_sentiment_gauge(outcomes))
        with col2:
            st.plotly_chart(create_emotion_radar(outcomes))

Streamlits Caching @st.cache_resource stellt sicher, dass Modelle einmal geladen werden und über Interaktionen hinweg bestehen bleiben, was für eine reaktionsfähige Benutzererfahrung von entscheidender Bedeutung ist.

Abb. 7: Vollständiges Dashboard mit Seitenleistenoptionen und mehreren Visualisierungsregisterkarten

// Hauptmerkmale

• Audio hochladen (oder Beispieltranskripte zum Testen verwenden)
• Transkript mit Stimmungshervorhebungen anzeigen
• Zeitleiste der Emotionen (wenn der Anruf lang genug ist)
• Themenvisualisierung mit interaktiven Plotly-Diagrammen

// Caching für Leistung

Streamlit führt das Skript bei jeder Interaktion erneut aus. Um die Wiederaufbereitung schwerer Modelle zu vermeiden, verwenden wir @st.cache_resource:

@st.cache_resource
def load_models():
    return CallProcessor()

processor = load_models()

// Echtzeitverarbeitung

Wenn ein Benutzer eine Datei hochlädt, zeigen wir während der Verarbeitung einen Spinner an und zeigen dann sofort die Ergebnisse an:

if uploaded_file:
    with st.spinner("Transcribing and analyzing..."):
        outcome = processor.process_file(uploaded_file)
    st.success("Performed!")
    st.write(outcome("textual content"))
    st.metric("Sentiment", outcome("sentiment")("label"))

# Wiederholung praktischer Lektionen

Audioverarbeitung: Von der Wellenform zum Textual content

Die Magie von Whisper liegt in der Umwandlung des Mel-Spektrogramms. Das menschliche Gehör ist logarithmisch, das heißt, wir können tiefe Frequenzen besser erkennen als hohe. Die Mel-Skala ahmt dies nach, sodass das Modell eher wie ein Mensch „hört“. Das Spektrogramm ist im Wesentlichen ein 2D-Bild (Zeit vs. Frequenz), das der Transformer-Encoder ähnlich wie einen Bildausschnitt verarbeitet. Aus diesem Grund kommt Whisper intestine mit lauten Audiosignalen zurecht; es sieht das ganze Bild.

// Transformatorausgänge: Softmax vs. Sigmoid

• Softmax (Stimmung): Erzwingt die Summe der Wahrscheinlichkeiten zu 1. Dies ist preferrred für sich gegenseitig ausschließende Klassen, da ein Satz normalerweise nicht sowohl positiv als auch negativ ist.
• Sigmoid (Emotionen): Behandelt jede Klasse unabhängig. Ein Satz kann gleichzeitig freudig und überraschend sein. Sigmoid ermöglicht diese Überlappung.

Die Auswahl der richtigen Aktivierung ist für Ihre Problemdomäne von entscheidender Bedeutung.

// Erkenntnisse mit Visualisierung vermitteln

Ein gutes Dashboard kann mehr als nur Zahlen anzeigen; es erzählt eine Geschichte. Plotly-Diagramme sind interaktiv; Benutzer können mit der Maus darüber fahren, um Particulars anzuzeigen, in Zeitbereiche hineinzoomen und auf Legenden klicken, um zwischen Datenreihen umzuschalten. Dadurch werden Rohanalysen in umsetzbare Erkenntnisse umgewandelt.

// Ausführen der Anwendung

Um die Anwendung auszuführen, befolgen Sie die Schritte vom Anfang dieses Artikels. Testen Sie die Sentiment- und Emotionsanalyse ohne Audiodateien:

Dadurch wird Beispieltext durch die NLP-Modelle (Pure Language Processing) geführt und die Ergebnisse im Terminal angezeigt.

Analysieren Sie eine einzelne Aufnahme:

python principal.py --audio path/to/name.mp3

Stapelverarbeitung eines Verzeichnisses:

python principal.py --batch information/audio/

Für das vollständige interaktive Erlebnis:

python principal.py --dashboard

Offen http://localhost:8501 in Ihrem Browser.

Abb. 8: Terminalausgabe, die eine erfolgreiche Analyse mit Sentiment-Scores zeigt

# Abschluss

Wir haben ein vollständiges, offlinefähiges System aufgebaut, das Kundenanrufe transkribiert, Stimmungen und Emotionen analysiert und wiederkehrende Themen extrahiert – alles mit Open-Supply-Instruments. Dies ist eine produktionsreife Grundlage für:

• Kundensupportteams identifizieren Schwachstellen
• Produktmanager sammeln Suggestions in großem Umfang
• Qualitätssicherung, Überwachung der Agentenleistung

Das Beste daran? Alles läuft lokal, respektiert die Privatsphäre der Benutzer und eliminiert API-Kosten.

Der vollständige Code ist auf GitHub verfügbar: Eine KI, die die Kundenstimmung analysiert. Klonen Sie das Repository, folgen Sie diesem lokalen KI-Sprach-zu-Textual content-Tutorial und beginnen Sie noch heute damit, Erkenntnisse aus Ihren Kundenanrufen zu gewinnen.

Shittu Olumid ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich dafür einsetzt, modernste Technologien zu nutzen, um fesselnde Erzählungen zu erschaffen, mit einem scharfen Blick fürs Element und einem Gespür für die Vereinfachung komplexer Konzepte. Sie können Shittu auch auf finden Twitter.

eine kleine NumPy-Projektreihe, in der ich es tatsächlich versuche etwas bauen mit NumPy, anstatt nur zufällige Funktionen und Dokumentation durchzugehen. Ich hatte immer das Gefühl, dass der beste Weg zum Lernen darin besteht, etwas zu tun. Deshalb wollte ich in diesem Projekt etwas sowohl Praktisches als auch Persönliches schaffen.

Die Idee conflict einfach: Analysieren Sie meine täglichen Gewohnheiten – Schlaf, Lernstunden, Bildschirmzeit, Bewegung und Stimmung – und sehen Sie, wie sie sich auf meine Produktivität und mein allgemeines Wohlbefinden auswirken. Die Daten sind nicht actual; Es ist fiktiv und über einen Zeitraum von 30 Tagen simuliert. Aber das Ziel ist nicht die Genauigkeit der Daten – es geht darum zu lernen, wie man NumPy sinnvoll nutzt.

Lassen Sie uns den Prozess Schritt für Schritt durchgehen.

Schritt 1 – Laden und Verstehen der Daten

Ich begann damit, ein einfaches NumPy-Array zu erstellen, das 30 Zeilen (eine für jeden Tag) und sechs Spalten enthielt – jede Spalte repräsentierte eine andere Gewohnheitsmetrik. Dann habe ich es als gespeichert .npy Datei, damit ich sie später problemlos laden kann.

# TODO: Import NumPy and cargo the .npy information file
import numpy as np
information = np.load(‘activity_data.npy’)

Nach dem Laden wollte ich bestätigen, dass alles wie erwartet aussah. Additionally habe ich das überprüft Type (um zu wissen, wie viele Zeilen und Spalten es gab) und die Anzahl der Dimensionen (um zu bestätigen, dass es sich um eine 2D-Tabelle und nicht um eine 1D-Liste handelt).

# TODO: Print array form, first few rows, and so forth.
information.form
information.ndim

AUSGABE: 30 Zeilen, 6 Spalten und ndim=2

Ich habe auch die ersten paar Zeilen ausgedruckt, um visuell zu bestätigen, dass jeder Wert in Ordnung conflict – zum Beispiel, dass die Schlafstunden nicht negativ waren oder dass die Stimmungswerte in einem angemessenen Bereich lagen.

# TODO: High 5 rows
information(:5)

Ausgabe:

array((( 1. , 6.5, 5. , 4.2, 20. , 6. ),
( 2. , 7.2, 6. , 3.1, 35. , 7. ),
( 3. , 5.8, 4. , 5.5, 0. , 5. ),
( 4. , 8. , 7. , 2.5, 30. , 8. ),
( 5. , 6. , 5. , 4.8, 10. , 6. )))

Schritt 2 – Validierung der Daten

Bevor ich eine Analyse durchführte, wollte ich sicherstellen, dass die Daten Sinn ergeben. Dies ist etwas, was wir bei der Arbeit mit fiktiven Daten oft überspringen, aber es ist dennoch eine gute Vorgehensweise.

Additionally habe ich nachgeschaut:

• Keine negativen Schlafstunden
• Keine Stimmung hat einen Wert unter 1 oder über 10

Für den Schlaf bedeutete das, die Schlafspalte (Index 1 in meinem Array) auszuwählen und zu prüfen, ob Werte unter Null lagen.

# Ensure values are affordable (no unfavorable sleep)
information(:, 1) < 0

Ausgabe:

array((False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False))

Das bedeutet, dass es keine Nachteile gibt. Dann habe ich das Gleiche für die Stimmung gemacht. Ich zählte, um herauszufinden, dass die Stimmungsspalte den Index 5 hatte, und überprüfte, ob einer unter 1 oder über 10 lag.

# Is temper out of vary?
information(:, 5) < 1
information(:, 5) > 10

Wir haben die gleiche Ausgabe erhalten.

Alles sah intestine aus, additionally konnten wir weitermachen.

Schritt 3 – Aufteilen der Daten in Wochen

Ich hatte 30 Tage Daten und wollte sie Woche für Woche analysieren. Der erste Instinkt conflict, NumPys zu verwenden cut up() Funktion, aber das ist fehlgeschlagen, weil 30 nicht gleichmäßig durch 4 teilbar ist. Additionally habe ich stattdessen verwendet np.array_split()was ungleichmäßige Teilungen ermöglicht.

Das hat mir Folgendes gebracht:

• Woche 1 → 8 Tage
• Woche 2 → 8 Tage
• Woche 3 → 7 Tage
• Woche 4 → 7 Tage

# TODO: Slice information into week 1, week 2, week 3, week 4
weekly_data = np.array_split(information, 4)
weekly_data

Ausgabe:

(array((( 1. , 6.5, 5. , 4.2, 20. , 6. ),
( 2. , 7.2, 6. , 3.1, 35. , 7. ),
( 3. , 5.8, 4. , 5.5, 0. , 5. ),
( 4. , 8. , 7. , 2.5, 30. , 8. ),
( 5. , 6. , 5. , 4.8, 10. , 6. ),
( 6. , 7.5, 6. , 3.3, 25. , 7. ),
( 7. , 8.2, 3. , 6.1, 40. , 7. ),
( 8. , 6.3, 4. , 5. , 15. , 6. ))),

array((( 9. , 7. , 6. , 3.2, 30. , 7. ),
(10. , 5.5, 3. , 6.8, 0. , 5. ),
(11. , 7.8, 7. , 2.9, 25. , 8. ),
(12. , 6.1, 5. , 4.5, 15. , 6. ),
(13. , 7.4, 6. , 3.7, 30. , 7. ),
(14. , 8.1, 2. , 6.5, 50. , 7. ),
(15. , 6.6, 5. , 4.1, 20. , 6. ),
(16. , 7.3, 6. , 3.4, 35. , 7. ))),

array(((17. , 5.9, 4. , 5.6, 5. , 5. ),
(18. , 8.3, 7. , 2.6, 30. , 8. ),
(19. , 6.2, 5. , 4.3, 10. , 6. ),
(20. , 7.6, 6. , 3.1, 25. , 7. ),
(21. , 8.4, 3. , 6.3, 40. , 7. ),
(22. , 6.4, 4. , 5.1, 15. , 6. ),
(23. , 7.1, 6. , 3.3, 30. , 7. ))),

array(((24. , 5.7, 3. , 6.7, 0. , 5. ),
(25. , 7.9, 7. , 2.8, 25. , 8. ),
(26. , 6.2, 5. , 4.4, 15. , 6. ),
(27. , 7.5, 6. , 3.5, 30. , 7. ),
(28. , 8. , 2. , 6.4, 50. , 7. ),
(29. , 6.5, 5. , 4.2, 20. , 6. ),
(30. , 7.4, 6. , 3.6, 35. , 7. ))))

Jetzt lagen die Daten in vier Blöcken vor, und ich konnte jeden einzelnen Teil problemlos analysieren.

Schritt 4 – Berechnung der wöchentlichen Kennzahlen

Ich wollte ein Gefühl dafür bekommen, wie sich jede Gewohnheit von Woche zu Woche verändert. Deshalb habe ich mich auf vier Hauptdinge konzentriert:

• Durchschnittlicher Schlaf
• Durchschnittliche Studienstunden
• Durchschnittliche Bildschirmzeit
• Durchschnittlicher Stimmungswert

Ich habe das Array jeder Woche in einer separaten Variablen gespeichert und dann verwendet np.imply() um die Durchschnittswerte für jede Metrik zu berechnen.

Durchschnittliche Schlafstunden

# retailer into variables
week_1 = weekly_data(0)
week_2 = weekly_data(1)
week_3 = weekly_data(2)
week_4 = weekly_data(3)

# TODO: Compute common sleep
week1_avg_sleep = np.imply(week_1(:, 1))
week2_avg_sleep = np.imply(week_2(:, 1))
week3_avg_sleep = np.imply(week_3(:, 1))
week4_avg_sleep = np.imply(week_4(:, 1))

Durchschnittliche Studienstunden

# TODO: Compute common research hours
week1_avg_study = np.imply(week_1(:, 2))
week2_avg_study = np.imply(week_2(:, 2))
week3_avg_study = np.imply(week_3(:, 2))
week4_avg_study = np.imply(week_4(:, 2))

Durchschnittliche Bildschirmzeit

# TODO: Compute common display time
week1_avg_screen = np.imply(week_1(:, 3))
week2_avg_screen = np.imply(week_2(:, 3))
week3_avg_screen = np.imply(week_3(:, 3))
week4_avg_screen = np.imply(week_4(:, 3))

Durchschnittlicher Stimmungswert

# TODO: Compute common temper rating
week1_avg_mood = np.imply(week_1(:, 5))
week2_avg_mood = np.imply(week_2(:, 5))
week3_avg_mood = np.imply(week_3(:, 5))
week4_avg_mood = np.imply(week_4(:, 5))

Um alles leichter lesbar zu machen, habe ich die Ergebnisse dann intestine formatiert.

# TODO: Show weekly outcomes clearly
print(f”Week 1 — Common sleep: {week1_avg_sleep:.2f} hrs, Examine: {week1_avg_study:.2f} hrs, “
f”Display time: {week1_avg_screen:.2f} hrs, Temper rating: {week1_avg_mood:.2f}”)

print(f”Week 2 — Common sleep: {week2_avg_sleep:.2f} hrs, Examine: {week2_avg_study:.2f} hrs, “
f”Display time: {week2_avg_screen:.2f} hrs, Temper rating: {week2_avg_mood:.2f}”)

print(f”Week 3 — Common sleep: {week3_avg_sleep:.2f} hrs, Examine: {week3_avg_study:.2f} hrs, “
f”Display time: {week3_avg_screen:.2f} hrs, Temper rating: {week3_avg_mood:.2f}”)

print(f”Week 4 — Common sleep: {week4_avg_sleep:.2f} hrs, Examine: {week4_avg_study:.2f} hrs, “
f”Display time: {week4_avg_screen:.2f} hrs, Temper rating: {week4_avg_mood:.2f}”)

Ausgabe:

Week 1 – Common sleep: 6.94 hrs, Examine: 5.00 hrs, Display time: 4.31 hrs, Temper rating: 6.50
Week 2 – Common sleep: 6.97 hrs, Examine: 5.00 hrs, Display time: 4.39 hrs, Temper rating: 6.62
Week 3 – Common sleep: 7.13 hrs, Examine: 5.00 hrs, Display time: 4.33 hrs, Temper rating: 6.57
Week 4 – Common sleep: 7.03 hrs, Examine: 4.86 hrs, Display time: 4.51 hrs, Temper rating: 6.57

Schritt 5 – Die Ergebnisse verstehen

Nachdem ich die Zahlen ausgedruckt hatte, tauchten einige Muster auf.

Mein Schlafstunden waren in den ersten zwei Wochen ziemlich konstant (ca. 6,9 Stunden), aber in der dritten Woche stiegen sie sprunghaft auf ca. 7,1 Stunden. Das bedeutet, dass ich im Laufe des Monats „besser geschlafen“ habe. Bis zur vierten Woche waren es ungefähr 7,0 Stunden.

Für Lernstundenes conflict das Gegenteil. In den Wochen eins und zwei waren es durchschnittlich etwa fünf Stunden professional Tag, in der vierten Woche waren es jedoch nur etwa vier Stunden. Grundsätzlich habe ich stark angefangen, aber langsam an Schwung verloren – was sich, ehrlich gesagt, ungefähr richtig anhört.

Dann kam Bildschirmzeit. Das tat ein bisschen weh. In der ersten Woche waren es ungefähr 4,3 Stunden professional Tag, und jede Woche wurden die Werte immer höher. Der klassische Zyklus, bei dem man früh produktiv ist und später im Monat langsam in weitere „Scroll-Pausen“ übergeht.

Endlich conflict es da Stimmung. Mein Stimmungswert begann in der ersten Woche bei etwa 6,5, stieg in der zweiten Woche leicht auf 6,6 und blieb dann für den Relaxation des Zeitraums auf diesem Wert. Es hat sich nicht dramatisch verändert, aber es conflict interessant, einen kleinen Anstieg in der zweiten Woche zu sehen – kurz bevor meine Lernstunden sanken und meine Bildschirmzeit zunahm.

Um die Dinge interaktiv zu gestalten, dachte ich, dass es großartig wäre, sie mit Matplotlib zu visualisieren.

Schritt 6 – Auf der Suche nach Mustern

Nachdem ich nun die Zahlen hatte, wollte ich es wissen Warum In der zweiten Woche stieg meine Laune.

Additionally habe ich die Wochen nebeneinander verglichen. Die zweite Woche hatte im Vergleich zu den späteren Wochen guten Schlaf, viele Lernstunden und relativ wenig Bildschirmzeit.

Das könnte erklären, warum mein Stimmungswert dort seinen Höhepunkt erreichte. Obwohl ich in der dritten Woche mehr schlief, begannen meine Lernstunden zu sinken – vielleicht ruhte ich mich mehr aus, schaffte aber weniger, was meine Stimmung nicht so sehr verbesserte, wie ich erwartet hatte.

Das hat mir an dem Projekt gefallen: Es geht nicht darum, dass die Daten echt sind, sondern darum, wie man das machen kann Verwenden Sie NumPy um Muster, Zusammenhänge und kleine Erkenntnisse zu erforschen. Selbst fiktive Daten können eine Geschichte erzählen, wenn man sie richtig betrachtet.

Schritt 7 – Zusammenfassung und nächste Schritte

In diesem kleinen Projekt habe ich ein paar wichtige Dinge gelernt – sowohl über NumPy als auch über die Strukturierung einer solchen Analyse.

Wir begannen mit einer Rohliste fiktiver Alltagsgewohnheiten, lernten, deren Struktur und Gültigkeit zu überprüfen, sie in sinnvolle Abschnitte (Wochen) aufzuteilen und verwendeten dann einfache NumPy-Operationen, um jedes Section zu analysieren.

Es handelt sich um ein kleines Projekt, das Sie daran erinnert, dass Datenanalyse nicht immer komplex sein muss. Manchmal geht es nur darum, einfache Fragen zu stellen wie „Wie verändert sich meine Bildschirmzeit im Laufe der Zeit?“ oder „Wann fühle ich mich am besten?“

Wenn ich das weiterführen möchte (was ich wahrscheinlich tun werde), gibt es so viele Richtungen, in die ich gehen kann:

• Finden Sie die beste und schlechteste Tage gesamt
• Vergleichen Wochentage vs. Wochenenden
• Oder erstellen Sie sogar einen einfachen „Wohlbefindens-Rating“, der auf der Kombination mehrerer Gewohnheiten basiert

Aber das wird wahrscheinlich für den nächsten Teil der Serie sein.

Im Second bin ich froh, dass ich NumPy auf etwas anwenden konnte, das sich actual und nachvollziehbar anfühlt – nicht nur abstrakte Arrays und Zahlen, sondern auch Gewohnheiten und Emotionen. Das ist die Artwork des Lernens, die hängen bleibt.

Danke fürs Lesen.

Wenn Sie die Serie verfolgen, versuchen Sie, sie anhand Ihrer eigenen fiktiven Daten nachzubilden. Selbst wenn Ihre Zahlen zufällig sind, lernen Sie mit diesem Prozess, wie Sie Arrays wie ein Profi aufteilen, aufteilen und analysieren.