A

ArizonaTay

@ArizonaTay·27 public vizzes

Loading thumbnail…

Gist 7324dc1c477b5214c422752e1390c042

Two horizontal bar charts display the percentage of sponsored posts by industry and by country, ranking the top twenty categories in descending order. The first chart highlights industries with the highest sponsorship rates, while the second compares countries, both using Plotly Express’s `px.bar` function. The code computes percentages by grouping the dataset with `groupby`, counting "Yes" and "No" values for the `Sponsored` column, merging results, and calculating proportions before sorting. Each chart is titled with centered layout via `update_layout(title_x=0.5)`, and the source data originates from a pandas DataFrame derived from the gist’s CSV.

Loading thumbnail…

Gist 905df75f1305bdbeb7b97d77c8fe96d2

A bar chart ranks the top 20 brands by the number of influencer collaborations, using a horizontal count of sponsored posts per sponsor. The visualization shows which brands appear most frequently in the influencer’s content, with higher counts indicating stronger collaboration presence. The code builds a Pandas DataFrame by extracting sponsor handles from a pre-existing `sponsored_df`, then groups and sorts the data before plotting with Plotly Express’s `px.bar`. Engagement rates are recorded alongside each sponsor, though the final chart displays only the frequency counts, not the engagement values.

Loading thumbnail…

Gist f911ff730b6f8a7d90f293521061801c

Two line charts from the same dataset show hourly trends for sponsored posts: the first displays average engagement rate by time of day, peaking at 4pm and 11pm, while the second shows the count of posts, with a maximum at 10am. Both use Plotly’s `go.Figure` and `go.Scatter` to render the lines, with x-axis labels formatted as `%H:%M:%S` from the index’s floor to the hour. Annotations via `add_annotation` highlight these peaks. The data comes from a pandas DataFrame filtered by `Sponsored == 'Yes'`, grouped by hourly floor.

Loading thumbnail…

Gist af6ed0a95b476ea7f82b0576a93a2306

This visualization displays the 30 most common words from a dataset of cleaned captions, using a frequency distribution to show which terms appear most often. The code filters out common exclusions like "1," "2," and "3" before processing, then relies on the Natural Language Toolkit’s `FreqDist` to count word occurrences. A bar chart is generated with `matplotlib.pyplot`, where the horizontal axis lists the top words and the vertical axis shows their raw frequencies. The plot is sized at 14 by 6 inches for readability, and the resulting figure is displayed directly via `plt.show()`, with the source being an internal data frame of cleaned captions.

Loading thumbnail…

Gist da5f7a5f8cf01b0874d92349b33ec806

This visualization uses a Latent Dirichlet Allocation (LDA) topic model to classify Instagram captions into eight thematic categories, such as Giveaway, Fitness, and Love. It first shows the derived topics with their top ten keywords per topic, then assigns each caption its dominant topic and displays a random sample of the resulting annotations. The analysis relies on the Gensim library for the LDA model and coherence scoring, while Pandas DataFrames and the Dictionary and doc2bow APIs handle text preprocessing and corpus construction. A custom function maps each caption’s topic distribution to its most likely label, and the final output presents a sample of the enriched data with the assigned topic column.

Loading thumbnail…

Gist dec05c8e23491da95f80ba891c35100a

This example trains a custom named entity recognition (NER) model using spaCy to identify sponsor mentions, product names, and promo codes in social media captions. It first preprocesses a data frame of captions by stripping non-alphabetic characters, then initializes a pre-trained English model and adds custom labels. Training uses 10 epochs with minibatch compounding and dropout, iterating over hand-labeled examples that mark entity spans. After training, the model is saved to disk and reloaded to test inference on new text, demonstrating the pipeline’s ability to extract promotional entities from informal, hashtag-heavy captions.

Loading thumbnail…

Gist 751982c1e21147b124a9b6d5fde96a4e

The visualization examines sponsored content in a social media dataset by processing raw captions through a custom pipeline. It uses Python’s `re` module to strip emojis and punctuation, then applies spaCy’s named entity recognition to extract organizations and products into a "Sponsor" list, while also capturing tags via string matching. The code builds a DataFrame with `pandas`, adding a binary "Sponsored" column based on whether either field is non-empty. It highlights the detection of promotional mentions by combining entity-based and rule-based tagging, ultimately displaying cleaned captions alongside the derived sponsorship metadata.

Loading thumbnail…

Gist 6437893f183d99e863d835425ffa46f8

This example visualizes the distribution of tokenized caption text from a dataset of images, showing how frequently each word appears after cleaning. The visualization displays the processed terms as a bar chart or word cloud, with the data derived from the `Caption` field of the input dataframe. The preprocessing pipeline loads the `en_core_web_lg` spaCy model to tokenize each caption, removes English stop words and non-alphanumeric characters, and converts all terms to lowercase. The code relies on the `spacy` library for linguistic analysis and standard Python regex operations via the `re` module to filter tokens, while the `stopwords` set comes from NLTK.

Loading thumbnail…

Gist 8f9cf917c41ea1240a5ea6b149d602dd

This visualization shows how the geographic spread of influencer locations relates to the frequency of their associated topics. It first loads influencer data from a CSV and a separate corpus of organization names, then renders the results using D3’s force-directed simulation to position nodes by influence, with geographic context provided by a d3.geoPath projection. The underlying text analysis relies on reading raw text files, while the visual encoding uses Canvas’s getImageData to sample pixel-level density for heatmapping, and transition.attrTween animates node movement as forces settle. The data source is explicitly read via pandas from the two files, and the rendering approach combines raster canvas operations with SVG overlays for labels and links.

Loading thumbnail…

Gist dfbc4b41961e5b098fffce6af3828f57

This visualization scrapes Instagram profile data to compare follower counts, post engagement, and captions across influencers in different industries. Using Selenium to automate Chrome and BeautifulSoup to parse page JSON, the script extracts post dates, like counts, comments, and partnership flags from each profile’s embedded `_sharedData` blob. It then compiles the results into a pandas DataFrame and exports them to CSV. The example highlights the workflow of collecting social-media metrics at scale, with the final chart likely plotting follower growth or engagement trends per industry.

Loading thumbnail…

Gist d2f2bc6be1716820160ed5183ea07eaa

This example shows a browser-based text analytics pipeline that scrapes and processes web content before visualizing topic models. The code first uses Selenium with Chrome WebDriver to scrape data, then applies NLP libraries including NLTK, spaCy, TextBlob, and gensim’s LdaModel for topic modeling and coherence scoring. The final visualization employs Plotly’s `plotly.express` and `plotly.graph_objs` to render interactive charts, with `pyo.init_notebook_mode()` enabling notebook display. The rendering approach is evident from the use of `go` traces and `px` figures, though the specific chart type is not shown in the code snippet. The data source is dynamic web pages, as indicated by the Selenium scraping logic.

Loading thumbnail…

Gist e049bb6d7696d1b2d4ff242e68fcd062

This example analyzes text data by performing topic modeling and visualization. It shows the resulting topics and their associated terms, revealing latent themes in the dataset. The code uses NLTK for tokenization and stopword removal, TextBlob for sentiment analysis, and Gensim’s LdaModel and CoherenceModel for topic extraction. Plotly’s `scatter` and `bar` traces render the interactive visualizations, with data processed from a pandas DataFrame. The rendering approach relies on Plotly’s offline mode, initiated via `pyo.init_notebook_mode()`.

Loading thumbnail…

Gist fbc8e33e01b5be01bc6c1ab2d1d08cfc

The visualization displays the 30 most frequently occurring words from a set of cleaned Instagram captions, plotted as a bar chart that ranks terms by raw count. It shows a sharp drop-off in frequency after the top few words, highlighting the long-tail distribution common in text data. The chart is generated using Python’s matplotlib, with the caption data loaded into a pandas DataFrame and tokenized via the Natural Language Toolkit (nltk). Frequencies are computed with `nltk.FreqDist`, and the top 30 entries are selected for plotting, with a filter excluding the characters ‘1’, ‘2’, and ‘3’ from the hashtag tokens. The figure is sized at 14 by 6 inches for readability.

Loading thumbnail…

Gist ba350b90fcee35acc38ff961c4eec95a

Two horizontal bar charts display the percentage of sponsored posts by industry and by country, using Plotly Express’s `px.bar` after grouping data with pandas `groupby` and `apply`. Each chart sorts its top 20 categories descending by sponsored share, with the industry chart titled “Sponsored Post(%) by Industry” and the country chart “Sponsored Post(%) by Country.” The code computes sponsored counts per category from the `inf_df` DataFrame, merges sponsored and non-sponsored totals, then calculates percentages for visualization. The source data appears to originate from a dataset of influencer posts, with plots rendered as static, interactive HTML figures.

Loading thumbnail…

Gist 95ca610ee079b0bdb562a98f57c792f4

The visualization displays the top 20 brands that collaborate with influencers, ranked by the frequency of their appearances in a dataset. It highlights which sponsors are most commonly associated with influencer posts, providing a clear view of brand partnership patterns. The chart is a horizontal bar plot generated using Plotly Express, with the `px.bar` function called on a sorted dataframe. The code processes the data by iterating through sponsored entries, cleaning sponsor names, and aggregating counts via `groupby` and `reset_index`. The final plot is styled with a title and centered axis labels, relying on Pandas for data manipulation.

Loading thumbnail…

Gist 0d66893f89c8190de7c21268dfeef1d1

The visualization explores sponsored Instagram posts, showing how engagement rates and posting frequency vary by hour of the day. Two line charts, built with Plotly Express and Plotly Graph Objects, reveal a peak in average engagement at 4pm and the highest number of posts at noon. A separate horizontal bar chart, also using Plotly, ranks the top 20 brand collaborators by counting how often each sponsor appears in the filtered dataset, which only includes posts marked as "Sponsored." The code groups timestamps by hour and processes sponsor tags by stripping "@" symbols to tally frequencies.

Loading thumbnail…

Gist e14e45693dae94f60b953c09a641f6a4

This example shows a data-processing pipeline that identifies and extracts potential sponsor names and tags from caption text. It classifies each row as “Yes” or “No” for sponsorship based on whether any sponsor or tag tokens are present. The code uses Python’s `re` module for emoji removal and text cleaning, and relies on spaCy’s named entity recognition (via `list_words.ents`) to detect organizations and products. It applies custom string-manipulation functions like `remove_emoji`, `pairList`, and `getTag` to filter and deduplicate extracted entities, then combines sponsor and tag columns before checking for non-empty results.

Loading thumbnail…

Gist 55fc864ec9cea1107845d3ed7a3dab8b

This example demonstrates a text-cleaning pipeline for caption data, showing how raw captions are converted into tokenized, filtered lists for downstream analysis. The visualization itself is not rendered; instead, the focus is on the data preprocessing logic. The code uses `pandas` with `apply` to run natural language processing via `spaCy` (`nlp`), extracting tokens from the `Caption` column. It then applies a custom `tokens` function that removes stop words and non-alphanumeric characters using `re.match`, while preserving tokens containing "@" symbols. The result is a new `clean_caption` column, highlighting a common step in text mining workflows.

Loading thumbnail…

Gist 6499e03ffdfc7479408da70f20af3625

This visualization maps the semantic relationships between words extracted from a text corpus. It shows a network of nodes and edges, where connected words cluster together based on their contextual similarity. The layout uses a force-directed graph, likely powered by d3.forceSimulation, to position nodes and links. The code loads a spaCy NLP model (`en_core_web_lg`) to compute word vectors, and filters out stop words using NLTK’s stopwords list before processing the raw text.

Loading thumbnail…

Gist 2c4db01f16e82a0746be7819b4d925d5

This example visualizes influencer engagement by computing an engagement rate from comment and like counts relative to follower totals, using pandas to add and inspect the new column. It then extracts URLs from post captions with a regex pattern, storing them in a new “Links” column to identify which posts contain external links. The code relies on pandas for data manipulation and the `str.extract` method for pattern matching, while the head and describe functions provide a quick statistical summary. The visualization focuses on showing how engagement varies with link presence, though no charting library is used in the provided snippet.

Loading thumbnail…

Gist 58c79c81e9a950a0cdafc7d2d0275742

This example shows a dynamic, browser-automated web-scraping workflow that captures rendered page content. It uses Selenium’s `webdriver` to launch a Chrome browser, wait for elements via `WebDriverWait` and `expected_conditions`, and then extracts page HTML with BeautifulSoup. The script programmatically sends keyboard inputs via `Keys`, and also employs the `requests` library for direct HTTP calls. It parses the returned data with `json`, timestamps actions with `datetime`, and structures results into a pandas DataFrame. The process includes randomized delays (`random` and `time`) to mimic human browsing behavior, though no explicit visualization or rendering library is used beyond the raw captured markup.

Loading thumbnail…

Gist 7083cd8264b6aa48ce4bbfaf44546f07

This example builds a profile-scraping pipeline for social media data, turning raw CSV input into a structured DataFrame with fields for user names, follower counts, post dates, likes, comments, captions, and industry tags. The code reads `raw_data.csv` via `pandas.read_csv` and then initializes an empty DataFrame with predefined column names, preparing it for subsequent population. The visualization focuses on the data-preparation stage rather than graphical output, demonstrating how pandas handles tabular ingestion and schema definition. No rendering library like d3 or Three.js appears here; instead, the emphasis is on clean data structuring for later analysis or charting.

Loading thumbnail…

Gist a99d287be62c6d73536521c0e5e74e58

This example scrapes Instagram profile and post data to track follower counts, likes, comments, captions, and post dates for selected users, associating each entry with an industry topic. The script uses Selenium to automate login and search, BeautifulSoup to parse the page source, and the Instagram GraphQL data embedded in `window._sharedData` to extract metrics. It writes the collected records to a CSV via pandas, pausing with random sleeps to avoid detection. The visualization highlights how social-media engagement varies across profiles and industries over time.

Loading thumbnail…

Gist 4aa3c41126f0bd7d7e9c92f4c7e7be4d

The visualization shows how influencer posts align with a predefined organizational corpus by mapping text overlap through a force-directed network layout. It loads influencer data and a static corpus list from CSV files, then uses Python’s pandas for data ingestion and likely computes similarity metrics. The rendering leverages a custom interactive graph—likely built with D3.js’s `d3.forceSimulation`—where nodes represent individual influencers and corpus terms, with edges weighted by textual matching. The code explicitly references `influencers_raw` and `orgcorpus_raw` to drive the analysis, while the visual output emphasizes clusters of semantic association. The approach relies on raw CSV parsing and a simulation engine, but no external charting library is imported in the shown snippet.

Loading thumbnail…

Gist fa05e9e0684e37e537c08085e5900435

This example shows a data-cleaning pipeline for an Instagram influencer dataset, highlighting the number of unique users and missing values across key columns. The code uses pandas to inspect and transform the data, filling missing industry labels with "General," dropping rows without captions, removing duplicate entries, and converting the post date column to datetime format for time-series indexing. The visualization relies on pandas' built-in data manipulation functions, such as `fillna`, `drop_duplicates`, and `set_index`, rather than a plotting library. The final output would be a cleaned dataframe ready for trend analysis, though no chart is generated in the provided script.

Loading thumbnail…

XY DV

This interactive visualization, titled “XY DV,” maps undergraduate course admission data from the National University of Singapore (NUS). It uses D3.js to render a scatterplot comparing each course’s Junior College (JC) cutoff grade (x-axis) against the Polytechnic (Poly) cutoff grade point average (y-axis), with each circle representing an individual course. Courses are color-coded by faculty, and the chart includes dropdown-style controls that let viewers filter the displayed courses by admission pathway—JC, polytechnic, or other qualifications—using animated transitions to update the points. Tooltips and axis labels clarify the relationship between the two cutoff metrics, making it easy to compare admission difficulty across disciplines. The visualization is built with D3 v3, renders as SVG, and is available under the MIT license.</this is a very concise description of the example. The files and README shown above are incomplete. I need to provide a very short and concise description of the visualization example, describing the key data and encodings. Do not include code in your description. Do not include any markdown formatting (no bullet points, no headers) in your description, just plain paragraphs. Write the description so it fits in a "gallery card" with maybe 2-3 sentences. Provide the response in JSON with the key "description" (escaped raw text). No other text. Ensure valid JSON, with the description as a single string. Escape double quotes if needed. { "description": "This interactive D3.js visualization, titled 'XY DV', explores university admission data from a Singaporean gist, mapping course-level metrics as a scatterplot with SVG animation. The chart compares JC and polytechnic cut-off points across NUS faculties, encoding quantitative values on both axes while using color or position to reveal relationships between entry requirements, course fees, and intake sizes. Hover or selection interactions likely highlight individual programs, allowing viewers to explore how different faculties and course types (e.g., Law, Medicine, Engineering) balance academic prerequisites and capacity. The minimalist

Loading thumbnail…

XY DV

This interactive visualization displays university course admission data as a zoomable partition layout, or sunburst diagram. Users filter courses by selecting their entry qualification type—JC, Poly, or Others—and specifying a cutoff point or work experience, which dynamically redraws the diagram to show only matching programs. The visualization is built with D3.js v3, using `d3.layout.partition`, `d3.svg.arc`, and SVG rendering with animations. Data is loaded from a JSON file containing details like course fees, intake size, and interview requirements.