Wir stellen vor: KitikiPlot, a Python-Bibliothek Entwickelt für die Visualisierung sequentieller und zeitreihenförmiger kategorialer „Gleitfenster“-Muster. Dieses modern Device soll Datenfachleuten in verschiedenen Bereichen, darunter Genomik, Luftqualitätsüberwachung und Wettervorhersage, die Möglichkeit geben, Erkenntnisse mit größerer Klarheit und Präzision zu gewinnen. Es ist einfach und vielseitig konzipiert, lässt sich nahtlos in das Datenökosystem von Python integrieren und bietet gleichzeitig optisch ansprechende Ausgaben für die Mustererkennung. Lassen Sie uns sein Potenzial erkunden und die Artwork und Weise der Analyse kategorialer Sequenzen verändern.

Lernziele

• Verstehen Sie die KitikiPlot-Schiebefenster-Visualisierungstechnik für sequentielle und kategoriale Zeitreihendaten.
• Erkunden Sie seine Parameter, um Visualisierungen für bestimmte Datensätze und Anwendungen anzupassen.
• Wenden Sie KitikiPlot in verschiedenen Bereichen an, einschließlich Genomik, Wetteranalyse und Luftqualitätsüberwachung.
• Entwickeln Sie Kenntnisse in der Visualisierung komplexer Datenmuster mit Python und Matplotlib.
• Erkennen Sie die Bedeutung visueller Klarheit bei der kategorialen Datenanalyse zur Verbesserung von Entscheidungsprozessen.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

KitikiPlot: Vereinfachen Sie die Visualisierung komplexer Daten

KitikiPlot ist ein leistungsstarkes Visualisierungstool zur Vereinfachung komplexer Datenanalyseinsbesondere für Anwendungen wie Schiebefensterdiagramme und dynamische Datendarstellung. Es bietet Flexibilität, lebendige Visualisierungen und nahtlose Integration mit Python und ist somit very best für Bereiche wie Genomik, Luftqualitätsüberwachung und Wettervorhersage. Mit seinen anpassbaren Funktionen wandelt KitikiPlot Rohdaten mühelos in eindrucksvolle visuelle Darstellungen um.

• KitikiPlot ist eine Python-Bibliothek zur Visualisierung sequentieller und zeitreihenbezogener kategorialer „Sliding Window“-Daten.
• Der Begriff ‚Kitiki‚(కిటికీ) bedeutet ‚Fenster‚ in Telugu.

Hauptmerkmale

• Schiebefenster: Die visuelle Darstellung besteht aus einem oder mehreren rechteckigen Balken, die jeweils Daten aus einem bestimmten Schiebefenster entsprechen.
• Rahmen: Jeder Balken ist in mehrere rechteckige Zellen unterteilt, die „Frames“ genannt werden. Diese Rahmen sind nebeneinander angeordnet und stellen jeweils einen Wert aus den sequentiellen kategorialen Daten dar.
• Anpassungsoptionen: Benutzer können Fenster umfassend anpassen, einschließlich Optionen für Farbkarten, Schraffurmuster und Ausrichtungen.
• Versatile Beschriftung: Die Bibliothek ermöglicht es Benutzern, Beschriftungen, Titel, Häkchen und Legenden nach ihren Wünschen anzupassen.

Erste Schritte: Ihre ersten Schritte mit KitikiPlot

Tauchen Sie mit dieser Kurzanleitung in die Welt von KitikiPlot ein. Von der Set up bis zu Ihrer ersten Visualisierung begleiten wir Sie durch jeden Schritt, damit Ihre Daten glänzen.

Installieren Sie KitikiPlot mit pip

pip set up kitikiplot

„Kitikiplot“ importieren

import pandas as pd
from kitikiplot import KitikiPlot

Laden Sie den Datenrahmen

Berücksichtigt wird der Datenrahmen „weatherHistory.csv“. https://www.kaggle.com/datasets/muthuj7/weather-dataset.

df= pd.read_csv( PATH_TO_CSV_FILE )
print("Form: ", df.form)
df= df.iloc(45:65, :)
print("Form: ", df.form)
df.head(3)

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( ) 

KitikiPlot-Parameter verstehen

Um die Leistungsfähigkeit von KitikiPlot voll auszuschöpfen, ist es wichtig, die verschiedenen Parameter zu verstehen, die steuern, wie Ihre Daten visualisiert werden. Mit diesen Parametern können Sie Aspekte wie Fenstergröße, Schrittintervalle und andere Einstellungen anpassen und so sicherstellen, dass Ihre Visualisierungen auf Ihre spezifischen Bedürfnisse zugeschnitten sind. In diesem Abschnitt werden wir wichtige Parameter aufschlüsseln, z stride Und window_length um Ihnen bei der Feinabstimmung Ihrer Diagramme zu helfen, um optimale Ergebnisse zu erzielen.

Schritt: int (non-compulsory)

• Die Anzahl der Elemente, die das Fenster nach jeder Iteration beim Konvertieren einer Liste in einen DataFrame verschieben soll.
• Der Standardwert ist 1.

index= 0
ktk= KitikiPlot( information= df("Abstract").values.tolist(), stride= 2 )
ktk.plot( cell_width= 2, transpose= True )

window_length: int (non-compulsory)

• Die Länge jedes Fensters beim Konvertieren einer Liste in einen DataFrame.
• Der Standardwert ist 10.

index= 0

ktk= KitikiPlot( information= df("Abstract").values.tolist(), window_length= 5 )

ktk.plot( transpose= True,
          xtick_prefix= "Body",
          ytick_prefix= "Window",
          cell_width= 2 )   

figsize: Tupel (non-compulsory)

• Die Größe der Figur (Breite, Höhe).
• Der Standardwert ist (25, 5).

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( figsize= (20, 8) )

cell_width: float

• Die Breite jeder Zelle im Raster.
• Der Standardwert ist 0,5.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( cell_width= 2 )

cell_height: float

• Die Höhe jeder Zelle im Raster.
• Der Standardwert ist 2.0.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( cell_height= 3 )

transponieren: bool (non-compulsory)

• Ein Flag, das angibt, ob der KitikiPlot transponiert werden soll.
• Der Standardwert ist False.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( transpose= False )

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( 
            cell_width= 2,
            transpose= True,
            xtick_prefix= "Body",
            ytick_prefix= "Window",
            xlabel= "Frames",
            ylabel= "Sliding_Windows" )

window_gap: float

• Die Lücke zwischen den Zellen im Raster.
• Der Standardwert ist 1,0.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( window_gap= 3 )

window_range: str oder tuple (non-compulsory)

• Der Bereich der anzuzeigenden Fenster.
• Verwenden Sie „all“, um alle Fenster anzuzeigen, oder geben Sie ein Tupel an (start_index, end_index).
• Der Standardwert ist „alle“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( window_range= "all" )

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( window_range= (3,8) )

ausrichten: bool

• Ein Flag, das angibt, ob aufeinanderfolgende Balken vertikal (wenn transpose= False) und horizontal (wenn transpose= True) um den Schrittwert verschoben werden sollen.
• Der Standardwert ist True.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( align= True )

ktk.plot( 
         align= False,
         display_yticks= False # Show no yticks
        )

ktk.plot( 
         cell_width= 2, 
         align= True, 
         transpose= True, 
         xlabel= "Frames",
         ylabel= "Sliding Home windows",
         xtick_prefix= "Body",
         ytick_prefix= "Window"
        )

ktk.plot( 
         cell_width= 2, 
         align= False, 
         transpose= True,
         xlabel= "Frames",
         ylabel= "Sliding Home windows",
         ytick_prefix= "Window",
         display_xticks= False 
        )

cmap: str oder dict

• Wenn es sich um eine Zeichenfolge handelt, sollte es sich um einen Farbkartennamen handeln, um Farben zu generieren.
• Wenn es sich um ein Wörterbuch handelt, sollte es eindeutige Werte bestimmten Farben zuordnen.
• Der Standardwert ist „Regenbogen“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( 
          cmap= "Greens",
          display_legend= True
        )

ktk.plot( 
          cmap= {"Principally Cloudy": "Inexperienced"},
          display_legend= True
        )

Kantenfarbe: str

• Die Farbe, die für die Kanten des Rechtecks ​​verwendet werden soll.
• Der Standardwert ist „#000000“.

ktk.plot( 
          cmap= {"Principally Cloudy": "Inexperienced"},
          fallback_color= "wheat",
          edge_color= "blue",
        )

fallback_color: str

• Die Farbe, die als Fallback verwendet werden soll, wenn keine bestimmte Farbe zugewiesen ist.
• Der Standardwert ist „#FAFAFA“.

ktk.plot( 
          cmap= {"Principally Cloudy": "Inexperienced"},
          fallback_color= "wheat",
          display_legend= True
        )

hmap: dict

• Ein Wörterbuch, das eindeutige Werte den entsprechenden Schraffurmustern zuordnet.
• Der Standardwert ist „{}“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( 
          cmap= {"Principally Cloudy": "gray"},
          fallback_color= "white",
          hmap= ",
          display_hatch= True
        )

fallback_hatch: str

• Das Schraffurmuster, das als Ersatz verwendet werden soll, wenn keine bestimmte Schraffur zugewiesen ist.
• Der Standardwert ist „“ „‘ (Zeichenfolge mit einem einzelnen Leerzeichen).

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( 
          cmap= {"Principally Cloudy": "gray"},
          fallback_color= "white",
          hmap= ",
          fallback_hatch= "",
          display_hatch= True
        )

display_hatch: bool

• Ein Flag, das angibt, ob Schraffurmuster auf Zellen angezeigt werden sollen.
• Der Standardwert ist False.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )

ktk.plot( 
          cmap= {"Principally Cloudy": "#ffffff"},
          fallback_color= "white",
          display_hatch= True
        )

xlabel: str (non-compulsory)

• Beschriftung für die x-Achse.
• Die Standardeinstellung ist „Schiebefenster“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( xlabel= "Commentary Window" )

ylabel: str (non-compulsory)

• Beschriftung für die y-Achse.
• Der Standardwert ist „Frames“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( ylabel= "Body ID" )

display_xticks: bool (non-compulsory)

• Ein Flag, das angibt, ob Xticks angezeigt werden sollen.
• Der Standardwert ist True.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( display_xticks= False )

display_yticks: bool (non-compulsory)

• Ein Flag, das angibt, ob Yticks angezeigt werden sollen
• Der Standardwert ist True

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( display_yticks= False )

xtick_prefix: str (non-compulsory)

• Präfix für Markierungsbeschriftungen der x-Achse.
• Die Standardeinstellung ist „Fenster“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( xtick_prefix= "Commentary" )

ytick_prefix: str (non-compulsory)

• Präfix für Y-Achsen-Teilstrichbeschriftungen.
• Der Standardwert ist „Rahmen“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( ytick_prefix= "Time" )

xticks_values: Liste (non-compulsory)

• Liste mit den Werten für xticks
• Customary ist ()

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
xtick_values= ('Begin', "T1", "T2", "T3", "T4", "T5", "T6", "T7", "T8", "T9", "Finish")
ktk.plot( xticks_values= xtick_values )

yticks_values: Liste (non-compulsory)

• Liste mit den Werten für Yticks
• Customary ist ()

ktk= KitikiPlot( information= df("Abstract").values.tolist() )

yticks_values= ((str(i.hour)+" "+i.strftime("%p").decrease()) for i in  pd.to_datetime(df("Formatted Date")))
ktk.plot( yticks_values= yticks_values )

xticks_rotation : int (non-compulsory)

• Drehwinkel für Teilstrichbeschriftungen der X-Achse.
• Der Standardwert ist 0.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( xticks_rotation= 45 )

yticks_rotation: int (non-compulsory)

• Drehwinkel für Y-Achsen-Teilstrichbeschriftungen.
• Der Standardwert ist 0.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )

ktk.plot( figsize= (20, 8),     # Improve top of the plot for good visualization (right here)
          yticks_rotation= 45 
        )

Titel: str (non-compulsory)

• Der Titel der Handlung.
• Die Standardeinstellung ist „KitikiPlot: Intuitive Visualisierung für Schiebefenster“.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( title= "KitikiPlot for Climate Dataset")

display_grid: bool (non-compulsory)

• Ein Flag, das angibt, ob ein Raster auf dem Plot angezeigt werden soll.
• Der Standardwert ist False.

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )
ktk.plot( display_grid= True )

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
          cell_width= 2,
          transpose= True,  
          xlabel= "Frames",
          ylabel= "Sliding Home windows",
          ytick_prefix= "Window",
          display_xticks= False,
          display_grid= True 
        )

display_legend: bool (non-compulsory)

• Ein Flag, das angibt, ob eine Legende auf dem Plot angezeigt werden soll.
• Der Standardwert ist False.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )
ktk.plot( display_legend= True )

legend_hatch: bool (non-compulsory)

• Ein Flag, das angibt, ob Schraffurmuster in die Legende einbezogen werden sollen.
• Der Standardwert ist False.

ktk= KitikiPlot( information= df("Abstract").values.tolist() )

ktk.plot( 
          cmap= {"Principally Cloudy": "#ffffff"},
          fallback_color= "white",
          display_hatch= True,
          display_legend= True,
          legend_hatch= True
        )

legend_kwargs: diktieren (non-compulsory)

• Zusätzliche Schlüsselwortargumente werden übergeben, um die Legende anzupassen.
• Der Standardwert ist {}.

Platzieren Sie die Legende außerhalb der Handlung

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
        figsize= (15, 5),
        display_legend= True,
        legend_kwargs= {"bbox_to_anchor": (1, 1.0), "loc":"higher left"} )

Titel für die Legende festlegen————————————

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
          figsize= (15, 5),
          display_legend= True,
          legend_kwargs= {"title": "Climate Circumstances"} 
        )

Kantenfarbe der Legende ändern

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
          figsize= (15, 5),
          display_legend= True,
          legend_kwargs= {"edgecolor": "lime"} 
        )

kitiki_cell_kwargs: diktieren (non-compulsory)

• Zusätzliche Schlüsselwortargumente werden übergeben, um einzelne Zellen anzupassen.
• Der Standardwert ist {}.

Legen Sie den Linienstil fest

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
        figsize= (15, 5),
        kitiki_cell_kwargs= {"linestyle": "--"} )

Passen Sie die Linienbreite an

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
        figsize= (15, 5),
        kitiki_cell_kwargs= {"linewidth": 3} )

Passen Sie das Alpha an

ktk= KitikiPlot( information= df("Abstract").values.tolist()(:15) )

ktk.plot( 
        figsize= (15, 5),
        kitiki_cell_kwargs= {"alpha": 0.4} )

Reale Anwendungen von KitikiPlot

KitikiPlot zeichnet sich in verschiedenen Bereichen aus, in denen die Datenvisualisierung für das Verständnis komplexer Muster und Developments von entscheidender Bedeutung ist. Von Genomik und Umweltüberwachung bis hin zu Finanzen und prädiktiver Modellierung ermöglicht KitikiPlot Benutzern, Rohdaten in klare, umsetzbare Erkenntnisse umzuwandeln. Ganz gleich, ob Sie große Datensätze analysieren, die Luftqualität im Zeitverlauf verfolgen oder Developments bei Aktienkursen visualisieren: KitikiPlot bietet die nötige Flexibilität und Anpassungsfähigkeit, um den einzigartigen Anforderungen verschiedener Branchen gerecht zu werden.

Genomik

• KitikiPlot ermöglicht eine klare Visualisierung von Gensequenzen und hilft Forschern, Muster und Motive zu identifizieren.
• Es erleichtert die Analyse struktureller Variationen im Genom, die für das Verständnis genetischer Störungen unerlässlich sind.
• Durch die Bereitstellung visueller Darstellungen hilft es bei der Interpretation komplexer Genomdaten und unterstützt Fortschritte in der personalisierten Medizin.

Datensatz-URL: https://archive.ics.uci.edu/dataset/69/molecular+biology+splice+junction+gene+sequences

# Import crucial libraries
from kitikiplot import KitikiPlot
import pandas as pd

# Load the dataset
df= pd.read_csv( "datasets/molecular+biology+splice+junction+gene+sequences/splice.information", header= None )

# Rename the columns
df.columns= ("Label", "Instance_Name", "Nucleotide_Sequence")

# Choose 3 gene sequences randomly
df= df.pattern(3, random_state= 1)

# Take away the white areas from the "Nucleotide_Sequence"
df("Nucleotide_Sequence")= df("Nucleotide_Sequence").str.strip()

df

index= 0

ktk= KitikiPlot( information= (i for i in df.iloc(index, 2)), stride= 1, window_length= len(df.iloc(index, 2)) )

ktk.plot(
        figsize= (20, 0.5),
        cell_width= 2,
        cmap= {'A': '#007FFF', 'T': "#fffc00", "G": "#00ff00", "C": "#960018"},
        transpose= True,
        xlabel= "Nucleotides",
        ylabel= "Sequence",
        display_yticks= False,
        xtick_prefix= "Nucleotide",
        xticks_rotation= 90,
        title= "Genome Visualization: "+df.iloc(index, 1).strip()+", Label : "+df.iloc(index,0).strip(),
        display_legend= True,
        legend_kwargs= {"bbox_to_anchor": (1.01, 1), "loc":'higher left', "borderaxespad": 0.})

Wettervorhersage

• Die Bibliothek kann zeitliche Wetterdaten wie Temperatur und Luftfeuchtigkeit über aufeinanderfolgende Zeitfenster effektiv darstellen, um Developments zu erkennen.
• Diese Visualisierung hilft bei der Erkennung von Mustern und Schwankungen der Wetterbedingungen und erhöht so die Genauigkeit von Vorhersagen.
• Darüber hinaus unterstützt es die Analyse historischer Daten und ermöglicht so bessere Vorhersagen und fundierte Entscheidungen hinsichtlich wetterbezogener Aktivitäten.

Datensatz-URL: https://www.kaggle.com/datasets/muthuj7/weather-dataset

# Import crucial libraries
from kitikiplot import KitikiPlot
import pandas as pd

# Learn csv
df= pd.read_csv( "datasets/weatherHistory/weatherHistory.csv")
print("Form: ", df.form)

# Choose a subset of information for visualization
df= df.iloc(45:65, :)
print("Form: ", df.form)

df.head(3)

index= 0

weather_data= ('Principally Cloudy', 'Overcast', 'Overcast', 'Overcast', 'Overcast', 'Overcast','Overcast', 'Overcast', 
               'Overcast', 'Principally Cloudy', 'Principally Cloudy', 'Partly Cloudy', 'Partly Cloudy', 'Partly Cloudy', 
               'Partly Cloudy', 'Principally Cloudy', 'Principally Cloudy', 'Principally Cloudy', 'Principally Cloudy', 'Principally Cloudy')
time_period= ('21 pm', '22 pm', '23 pm', '0 am', '1 am', '2 am', '3 am', '4 am', '5 am', '6 am', '7 am', '8 am', 
              '9 am', '10 am', '11 am', '12 pm', '13 pm', '14 pm', '15 pm', '16 pm')
ktk= KitikiPlot( information= weather_data, stride= 1, window_length= 10 )
ktk.plot(
        figsize= (20, 5),
        cell_width= 2,
        transpose= False,
        xlabel= "Window",
        ylabel= "Time",
        yticks_values= time_period,
        xticks_rotation= 90, 
        cmap= {"Principally Cloudy": "brown", "Partly Cloudy": "#a9cbe0","Overcast": "#fdbf6f"},
        legend_kwargs= {"bbox_to_anchor": (1.01, 1), "loc":'higher left', "borderaxespad": 0.},
        display_legend= True,
        title= "Climate Sample on 10-04-2006")

Überwachung der Luftqualität

• Benutzer können mit KitikiPlot den Schadstoffgehalt im Zeitverlauf analysieren, um Variationen und Korrelationen in Umweltdaten zu erkennen.
• Diese Fähigkeit ermöglicht die Identifizierung von Developments in der Luftqualität und ermöglicht ein tieferes Verständnis dafür, wie verschiedene Schadstoffe aufgrund verschiedener Faktoren interagieren und schwanken.
• Darüber hinaus unterstützt es die Untersuchung zeitlicher Beziehungen zwischen Luftqualitätsindizes und spezifischen Schadstoffen und erhöht so die Wirksamkeit der Maßnahmen zur Überwachung der Luftqualität.

Datensatz-URL: https://archive.ics.uci.edu/dataset/360/air+high quality

from kitikiplot import KitikiPlot
import pandas as pd

# Learn excel
df= pd.read_excel( "datasets/air+high quality/AirQualityUCI.xlsx" ) 

# Extract information from in the future (2004-11-01)
df= df( df('Date')== "2004-11-01" )
print("Form : ", df.form)
df.head( 3 )

# Convert float to int
df("CO(GT)")= df("CO(GT)").astype(int)

CO_values= (3, 3, 3, 3, -200, 2, 1, 1, 1, 1, 2, 3, 4, 4, 3, 3, 3, 2)
time_period= ('0 am', '1 am', '2 am', '3 am', '4 am', '5 am', '6 am', '7 am', '8 am', '9 am', '10 am',
              '11 am', '12 pm', '13 pm', '14 pm', '15 pm', '16 pm', '17 pm')
ktk= KitikiPlot( information= CO_values )
ktk.plot(
        figsize= (20, 5),
        cell_width= 2,
        cmap= {-200: "cornflowerblue", 1: "#ffeaea", 2: "#feb9b9", 3: "#ff7070", 4: "#b00"},
        transpose= True,
        xlabel= "Time",
        ylabel= "Sliding Home windows of CO(GT) values (in mg/m^3)",
        display_xticks= True,
        xticks_values= time_period,
        ytick_prefix= "Window",
        xticks_rotation= 90, 
        display_legend= True,
        title= "CO(GT) Development in Air",
        legend_kwargs= {"bbox_to_anchor": (1.01, 1), "loc":'higher left', "borderaxespad": 0.})

Abschluss

KitikiPlot vereinfacht die Visualisierung von sequentiellen und zeitreihenbasierten kategorialen Schiebefensterdaten und macht komplexe Muster besser interpretierbar. Seine Vielseitigkeit erstreckt sich über verschiedene Anwendungen, darunter Genomik, Wetteranalyse und Luftqualitätsüberwachung, und unterstreicht seinen breiten Nutzen sowohl in der Forschung als auch in der Industrie. Mit einem Fokus auf Klarheit und Benutzerfreundlichkeit verbessert KitikiPlot die Extraktion umsetzbarer Erkenntnisse aus kategorialen Daten. Als Open-Supply-Bibliothek ermöglicht sie Datenwissenschaftlern und -forschern, vielfältige Herausforderungen effektiv zu bewältigen.

Wichtige Erkenntnisse

• KitikiPlot ist eine vielseitige Python-Bibliothek, die für präzise und benutzerfreundliche Datenvisualisierungen mit Schiebefenstern entwickelt wurde.
• Dank der anpassbaren Parameter können Benutzer aussagekräftige und interpretierbare Visualisierungen erstellen, die auf ihre Datensätze zugeschnitten sind.
• Die Bibliothek unterstützt eine breite Palette realer Anwendungen in verschiedenen Forschungs- und Industriebereichen.
• Als Open-Supply-Device gewährleistet KitikiPlot die Zugänglichkeit für Praktiker und Forscher der Datenwissenschaft gleichermaßen.
• Klare und aufschlussreiche Visualisierungen erleichtern die Identifizierung von Developments in sequentiellen kategorialen Daten.

Ressourcen

Zitat

@software program{ KitikiPlot_2024
creator = {Boddu Sri Pavan and Boddu Swathi Sree},
title = {{KitikiPlot: A Python library to visualise categorical sliding window information}},
yr = {2024},
model = {0.1.2},
url = {url{https://github.com/BodduSriPavan-111/kitikiplot},
doi = {10.5281/zenodo.14293030}
howpublished = {url{https://github.com/BodduSriPavan-111/kitikiplot}}
}

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Über ein Jahr Berufserfahrung als KI-ML-Ingenieur habe ich hochmoderne Modelle für die Erkennung der menschlichen Körperhaltung sowie Hand- und Mundgestenerkennungssysteme mit einer Genauigkeit von +90 % entwickelt. Ich freue mich darauf, meine Arbeit zum datengesteuerten maschinellen Lernen fortzusetzen.

Bild von creativeart auf Freepik

Zeitreihendaten sind einzigartig, da sie sequenziell voneinander abhängen. Dies liegt daran, dass die Daten im Laufe der Zeit in konsistenten Intervallen erfasst werden, beispielsweise jährlich, täglich oder sogar stündlich.

Zeitreihendaten sind für viele Analysen wichtig, da sie Muster für geschäftliche Fragen wie Datenprognosen, Anomalieerkennung, Trendanalysen und mehr darstellen können.

In Python können Sie versuchen, den Zeitreihendatensatz mit NumPy zu analysieren. NumPy ist ein leistungsstarkes Paket für numerische und statistische Berechnungen, kann aber auf Zeitreihendaten erweitert werden.

Wie das geht, probieren wir es aus.

Zeitreihendaten mit NumPy

Zuerst müssen wir NumPy in unserer Python-Umgebung installieren. Sie können das mit dem folgenden Code tun, falls Sie das noch nicht getan haben.

Als nächstes versuchen wir, Zeitreihendaten mit NumPy zu initiieren. Wie bereits erwähnt, haben Zeitreihendaten sequentielle und zeitliche Eigenschaften, daher würden wir versuchen, sie mit NumPy zu erstellen.

import numpy as np

dates = np.array(('2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05'), dtype="datetime64")
dates

Output>>
array(('2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04',
       '2023-01-05'), dtype="datetime64(D)")

Wie Sie im obigen Code sehen können, setzen wir die Datenzeitreihe in NumPy mit dem dtype Parameter. Ohne sie würden die Daten als Zeichenfolgendaten betrachtet, jetzt jedoch als Zeitreihendaten.

Wir können die NumPy-Zeitreihendaten erstellen, ohne sie einzeln zu schreiben. Dazu können wir eine bestimmte Methode von NumPy verwenden.

date_range = np.arange('2023-01-01', '2025-01-01', dtype="datetime64(M)")
date_range

Output>>
array(('2023-01', '2023-02', '2023-03', '2023-04', '2023-05', '2023-06',
       '2023-07', '2023-08', '2023-09', '2023-10', '2023-11', '2023-12',
       '2024-01', '2024-02', '2024-03', '2024-04', '2024-05', '2024-06',
       '2024-07', '2024-08', '2024-09', '2024-10', '2024-11', '2024-12'),
      dtype="datetime64(M)")

Wir erstellen monatliche Daten von 2023 bis 2024, wobei die Daten jedes Monats die Werte darstellen.

Danach können wir versuchen, die Daten basierend auf der NumPy-Datums-/Uhrzeitreihe zu analysieren. Wir können beispielsweise Zufallsdaten mit einem Datumsbereich erstellen, der unserem Datumsbereich entspricht.

information = np.random.randn(len(date_range)) * 10 + 100 

Output>>
array((128.85379394,  92.17272879,  81.73341807,  97.68879621,
       116.26500413,  89.83992529,  93.74247891, 115.50965063,
        88.05478692, 106.24013365,  92.84193254,  96.70640287,
        93.67819695, 106.1624716 ,  97.64298602, 115.69882628,
       110.88460629,  97.10538592,  98.57359395, 122.08098289,
       104.55571757, 100.74572336,  98.02508889, 106.47247489))

Mit der Zufallsmethode in NumPy können wir Zufallswerte generieren, um Zeitreihenanalysen zu simulieren.

Beispielsweise können wir versuchen, mit NumPy mithilfe des folgenden Codes eine gleitende Durchschnittsanalyse durchzuführen.

def moving_average(information, window):
    return np.convolve(information, np.ones(window), 'legitimate') / window

ma_12 = moving_average(information, 12)
ma_12

Output>>
array(( 99.97075433,  97.03945458,  98.20526648,  99.53106381,
       101.03189965, 100.58353316, 101.18898821, 101.59158114,
       102.13919216, 103.51426971, 103.05640219, 103.48833188,
       104.30217122))

Der gleitende Durchschnitt ist eine einfache Zeitreihenanalyse, bei der wir den Mittelwert der Teilmengennummer der Reihe berechnen. Im obigen Beispiel verwenden wir Fenster 12 als Teilmenge. Das bedeutet, dass wir die ersten 12 der Reihe als Teilmenge nehmen und ihre Mittelwerte ermitteln. Dann verschiebt sich die Teilmenge um eins und wir nehmen die nächste mittlere Teilmenge.

Die erste Teilmenge ist additionally diese Teilmenge, bei der wir den Mittelwert nehmen:

(128.85379394,  92.17272879,  81.73341807,  97.68879621,
       116.26500413,  89.83992529,  93.74247891, 115.50965063,
        88.05478692, 106.24013365,  92.84193254,  96.70640287)

In der nächsten Teilmenge verschieben wir das Fenster um eins:

(92.17272879,  81.73341807,  97.68879621,
       116.26500413,  89.83992529,  93.74247891, 115.50965063,
        88.05478692, 106.24013365,  92.84193254,  96.70640287,
        93.67819695)

Das ist, was die np.convolve tut, als würde die Methode verschieben und summieren die Serie Teilmenge so viel wie die np.ones Array-Nummer. Wir verwenden die gültige Possibility nur, um den Betrag zurückzugeben, der ohne Auffüllen berechnet werden kann.

Dennoch werden gleitende Durchschnitte häufig zur Analyse von Zeitreihendaten verwendet, um das zugrunde liegende Muster zu erkennen und als Signale, beispielsweise für Kauf/Verkauf im Finanzbereich.

Apropos Muster: Wir können die Trenddaten in Zeitreihen mit NumPy simulieren. Der Development ist eine langfristige und anhaltende Richtungsbewegung in den Daten. Im Grunde ist es die allgemeine Richtung, in der die Zeitreihendaten verlaufen würden.

pattern = np.polyfit(np.arange(len(information)), information, 1)
pattern

Output>>
array(( 0.20421765, 99.78795983))

Was oben passiert, ist, dass wir eine lineare Gerade an unsere obigen Daten anpassen. Aus dem Ergebnis erhalten wir die Steigung der Linie (erste Zahl) und den Achsenabschnitt (zweite Zahl). Die Steigung stellt dar, wie stark sich die Daten professional Schritt oder zeitliche Werte im Durchschnitt ändern, während der Achsenabschnitt die Datenrichtung angibt (positiv bedeutet nach oben und negativ bedeutet nach unten).

Wir können auch trendbereinigte Daten haben, additionally die Komponenten, nachdem wir den Development aus der Zeitreihe entfernt haben. Dieser Datentyp wird häufig verwendet, um Fluktuationsmuster in den Trenddaten und Anomalien zu erkennen.

detrended = information - (pattern(0) * np.arange(len(information)) + pattern(1))
detrended

Output>>
array(( 29.06583411,  -7.81944869, -18.46297706,  -2.71181657,
        15.66017371, -10.96912278,  -7.2707868 ,  14.29216727,
       -13.36691409,   4.61421499,  -8.98820376,  -5.32795108,
        -8.56037465,   3.71968235,  -5.00402087,  12.84760174,
         7.8291641 ,  -6.15427392,  -4.89028352,  18.41288776,
         0.6834048 ,  -3.33080706,  -6.25565918,   1.98750918))

Die Daten ohne ihren Development werden in der Ausgabe oben angezeigt. In einer realen Anwendung würden wir sie analysieren, um zu sehen, welche zu stark vom allgemeinen Muster abweichen.

Wir können auch versuchen, die Saisonalität anhand der uns vorliegenden Zeitreihendaten zu analysieren. Saisonalität bezeichnet regelmäßige und vorhersehbare Muster, die in bestimmten Zeitabständen auftreten, beispielsweise alle 3 Monate, alle 6 Monate usw. Saisonalität wird normalerweise durch externe Faktoren wie Feiertage, Wetter, Veranstaltungen usw. beeinflusst.

seasonality = np.imply(information.reshape(-1, 12), axis=0)
seasonal_component = np.tile(seasonality, len(information)//12 + 1)(:len(information))

Output>>
array((111.26599544,  99.16760019,  89.68820205, 106.69381124,
       113.57480521,  93.4726556 ,  96.15803643, 118.79531676,
        96.30525224, 103.4929285 ,  95.43351072, 101.58943888,
       111.26599544,  99.16760019,  89.68820205, 106.69381124,
       113.57480521,  93.4726556 ,  96.15803643, 118.79531676,
        96.30525224, 103.4929285 ,  95.43351072, 101.58943888))

Im obigen Code berechnen wir den Durchschnitt für jeden Monat und erweitern dann die Daten, um sie seiner Länge anzupassen. Am Ende erhalten wir den Durchschnitt für jeden Monat im Zweijahresintervall und können versuchen, die Daten zu analysieren, um festzustellen, ob es nennenswerte Saisonalität gibt.

Das sind alle grundlegenden Methoden, die wir mit NumPy für Zeitreihendaten und -analysen durchführen können. Es gibt viele erweiterte Methoden, aber die oben genannten sind die grundlegenden Methoden, die wir durchführen können.

Abschluss

Die Zeitreihendaten sind ein einzigartiger Datensatz, da sie sequenziell dargestellt werden und zeitliche Eigenschaften haben. Mit NumPy können wir die Zeitreihendaten festlegen, während wir grundlegende Zeitreihenanalysen wie gleitende Durchschnitte, Trendanalysen und Saisonalitätsanalysen durchführen. Daten, während wir grundlegende Zeitreihenanalysen wie gleitende Durchschnitte, Trendanalysen und Saisonalitätsanalysen durchführen.

Cornellius Yudha Wijaya ist Information Science Assistant Supervisor und Datenautor. Während seiner Vollzeitbeschäftigung bei Allianz Indonesien teilt er gerne Python- und Datentipps über soziale Medien und in den Medien. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.