html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd" https://www.cgchannel.com/wp-content/uploads/2024/02/240206_Cavalry2_particles.mp4 Originally posted on 6 February 2024. Scroll down for news of the Cavalry 2.4 update. Scene Group has begun the next big series of releases for Cavalry, its motion design software. Cavalry 2.0 adds animatable scene cameras, making it possible to create 2.5D effects, plus an experimental new particle system, and increases scene playback speed around 200%. A next-gen 2D motion graphics tool inspired by 3D software Originally released in 2020, Cavalry is a procedural animation app “combining the power and flexibility of 3D with the ease of use of 2D”.Although currently a pure 2D animation tool, it supports workflows that will be familiar to 3D animators, including keyframing, curve editing, deformation, rigging, scattering and instancing. Scene Group’s background is also in 3D motion graphics: the firm is a spin-off from Mainframe North, which developed MASH, Maya’s motion graphics toolset. Once created, images may be exported in a range of file formats, including as JPEG, PNG or SVG sequences, as animated PNGs, as WEBM or QuickTime movies, or in Lottie format. https://www.cgchannel.com/wp-content/uploads/2024/02/240206_Cavalry2_cameras.mp4 Add a Camera to a scene to create 2.5D animations Major changes in Cavalry 2.0 include support for Cameras, making it possible to create 2.5D effects like the one above.Users can create Freeform or Look At cameras, with the option to offset the position of the camera and look-at target to create secondary motion, and to set view distance limits for layers. Experimental new particle system creates 2D particle effects Cavalry 2.0 also introduces an experimental new particle system, for creating particle effects.It’s still a tech preview, but it already includes a range of standard basic features, including settings for particle shape, and a range of emitter types and modifiers. Particles can be emitted from points, shapes, paths or Distributions; and it is possible to direct particle motion with paths, goals, forces or turbulence. Other new features and performance improvements Other new features in Cavalry 2.0 include a new Auto-Animate behavior for animating Shapes with fewer keyframes, and support for tapered strokes along Shapes.Workflow improvements include the option to set up overrides for Pre-Comps, making it easier to create variants for a composition. Users can also now group Layers into simplified custom containers called Components, controlling which Attributes are exposed in the UI. Performance improvements include boosts of 10-600% in playback speed: the improvement is greater in complex scenes, but Scene Group says that the average is around 200%. Cavalry also now supports background rendering, making it possible to continue to work while a scene is rendering. https://www.cgchannel.com/wp-content/uploads/2024/02/240524_Cavalry21_tw.mp4 Updated 23 May 2024: Scene Group has released Cavalry 2.1. The update focuses on the audio tools, adding support for multi-track audio playback, and the option to export audio from Cavalry. Audio projects can be exported as AAC files, or in MP4, QuickTime or WebM files. It is also possible to import audio files in more formats, now including AAC, MP3 and CAF. Updated 11 November 2024: Scene Group has released Cavalry 2.2. The biggest change in the update is support for OpenType fonts in the Text Shape, with the option to control OpenType features like ligatures and superscript procedurally. It is also possible to create color gradients along Strokes, and to add multiple Strokes to paths. Other changes include the option to fill closed paths with Stitches, new Sweep and Shape Falloff patterns, a new Quick Mask mode, and proportional easing when scaling keyframes. Users of the paid Pro edition also get a new Knot behavior, which automatically adds gaps to paths where they self-intersect, and a new Stroke Duplicator feature. Released 11 December 2025: Scene Group has released Cavalry 2.3. Workflow improvements include the option to save presets for Layers, Compositions and Render Queue Items, and to ‘seed‘ random values for Attributes. Users of the Pro edition get the option to open multiple viewports, and to convert images or shape layers to contours, and to convert contours within shapes to sub-meshes. Updated 15 May 2025: Scene Group has released Cavalry 2.4. It’s a sizeable update, adding the option to write custom image-manipulation filters in SkSL, and save them as third-party plugins. SkSL, the shading language used by open-source 2D graphics library Skia, is a variant of GLSL, so code from sites like Shadertoy should work with “minor modifications”. The update also adds a new SLA shader for creating a range of animatable noise types. Text styling and .xslx import Other changes include new styling options in the Text Shape, making it possible to apply apply effects like underline, strikethrough and superscript to text.It is also now possible to import Excel .xslx files. Pro edition: use 2D meshes to deform images and shaders Users of the paid Pro edition also get the option to create 2D meshes to deform images or shaders by placing control vertices.When creating 2.5D animation, it is now possible to use a Camera Guide – a representation of the region of the scene visible to the camera – to drive its animation. For managing complex projects, a new Dependency Graph window provides an editable schematic view of a composition, replacing the old Flow Graph. Price and system requirements Cavalry 2.4 is available for Windows 10+ and macOS 12.0+. The full software is available rental-only, with Pro subscriptions costing £192/year (around $255/year). The free edition caps renders at full HD resolution, and lacks the advanced features in this table. Read a full list of new features in Cavalry in the online release notes Read an overview of original Cavalry 2.0 update on Scene Group’s blog Have your say on this story by following CG Channel on Facebook, Instagram and X (formerly Twitter). As well as being able to comment on stories, followers of our social media accounts can see videos we don’t post on the site itself, including making-ofs for the latest VFX movies, animations, games cinematics and motion graphics projects.

Quantization is one of the key techniques for reducing the memory footprint of large language models (LLMs). It works by converting the data type of model parameters from higher-precision formats such as 32-bit floating point (FP32) or 16-bit floating point (FP16/BF16) to lower-precision integer formats, typically INT8 or INT4. For example, quantizing a model to 4-bit means each parameter uses only 0.5 bytes, compared to 4 bytes in FP32. Post-training quantization methods like GPTQ and AWQ can dramatically reduce the size of large models. A model like Llama 3 with 70 billion parameters can occupy around 140 GB in FP16, but this can be reduced to approximately 40 GB using 4-bit quantization, while still maintaining strong performance on downstream tasks. However, despite this substantial reduction, such models still exceed the memory capacity of most consumer-grade GPUs, which typically offer 24 GB to 32 GB of VRAM. To make these models truly accessible, quantization to even lower bitwidths, such as 2-bit, is required. While recent advances in low-bit quantization are promising, achieving stable and accurate 2-bit quantization remains a significant challenge. In this article, we review a technique called EoRA that helps compensate for quantization-induced errors. EoRA is a training-free method, meaning it can be applied quickly and efficiently to any model, even the largest ones. We’ll check how EoRA works and demonstrate how it can significantly improve the performance of 2-bit quantized models, bringing them close to the accuracy of their full-precision counterparts while being up to 5.5x smaller. We’ll analyze experimental results obtained using large models such as Qwen3-32B and Qwen2.5-72B, both quantized to 2-bit using state-of-the-art quantization techniques, to illustrate the effectiveness of EoRA. Diving into the Eigenspace in Search of an Adapter Post-training quantization or, more generally, compression aims to reduce model size or inference cost by minimizing the output difference between the original weights Wl​ and compressed weights Ŵl  using only a small calibration dataset. Most quantization methods are framed layer-wise, but the choice of compression formats is rigid and limits flexibility across diverse deployment needs. To bypass format constraints and improve accuracy, previous work, such as QLoRA [1] and HQQ+ [2], directly fine-tuned a Lora adapter on top of the frozen quantized models. It is also possible to reframe compression as a compensation problem: given a compressed model, introduce low-rank residual paths that specifically correct compression errors. A straightforward method uses SVD to decompose the compression error: \[\Delta W_l = W_l – \hat{W}_l\] into \[U_l \Sigma_l V_l^T\] forming low-rank approximations via two matrices: \[B_l = U_l \Sigma_l \] \[A_l = V_l^T\] where Al and Bl are the standard tensors of a LoRA adapter. However, plain SVD has two limitations: it does not minimize the original layerwise compression loss directly, and it allocates capacity uniformly across all error components, ignoring the varying importance of different parts of the model. To address this, NVIDIA proposes EoRA [3]. EoRA: Training-free Compensation for Compressed LLM with Eigenspace Low-Rank Approximation EoRA first projects the compression error into the eigenspace defined by the input activation covariance: \[\tilde{X} \tilde{X}^T\] where X̃ is the average activation over the calibration set. Then, by performing eigendecomposition, we get: \[\tilde{X} \tilde{X}^T = Q \Lambda Q^T\] The compression error ΔW is projected as: \[\Delta W’ = \Delta W Q’\] where Q′=QΛ. Then SVD is applied on ΔW′ to produce a low-rank approximation, and the result is projected back to the original space, adjusting the low-rank factors accordingly. This eigenspace projection changes the optimization objective: it weights the importance of different error components according to their contribution to the layerwise output (via eigenvalues), making the approximation more efficient. It can be computed quickly without any training, requires only calibration activations, and does not introduce extra inference latency. Moreover, the derivation shows that this approach leads to a direct minimization of the layerwise compression loss, not just the raw weight error. Analytically, truncating a singular value in the projected space corresponds to minimizing the true compression error under reasonable assumptions about the calibration activations. In their paper, NVIDIA presents a wide range of strong results showing that EoRA can significantly boost the accuracy of quantized models. However, their experiments focus mostly on older Quantization methods like GPTQ and are limited to mid-sized LLMs, up to 13B parameters, at 3-bit and 4-bit precisions. This leaves an open question: can EoRA still be effective for much larger models, using more modern quantization techniques, and even pushing down to 2-bit precision? Let’s find out. Calibrating an EoRA Adapter Suppose we have quantized models that show significantly degraded performance compared to their full-precision counterparts on certain tasks. Our goal is to reduce this performance gap using EoRA. For the experiments, I used Qwen2.5-72B Instruct and Qwen3-32B, both quantized to 2-bit using AutoRound (Apache 2.0 license), a state-of-the-art quantization algorithm developed by Intel. AutoRound leverages SignSGD optimization to fine-tune quantization, and is particularly effective for low-bit settings. All the models I made are available here (Apache 2.0 license): Quantized Qwen3 Quantized Qwen2.5 The 2-bit models were quantized with a group size of 32, except for which used a group size of 128. A larger group size reduces model size by storing less quantization metadata, but it introduces greater quantization error. I evaluated the models on IFEval, a benchmark that measures instruction-following capabilities. Results showed a noticeable drop in performance for the quantized versions. Image by the author To compensate for this degradation, I applied an EoRA adapter using the implementation provided in the GPTQModel library (licensed under Apache 2.0). The integration is straightforward. If you’re curious about how it’s implemented in PyTorch, the codebase is compact, clean, and easy to follow: GPTQModel’s EoRA implementation: eora.py EoRA requires a calibration dataset. Ideally, this dataset should reflect the model’s intended use case. However, since we don’t have a specific target task in this context and aim to preserve the model’s general capabilities, I used 1,024 randomly sampled examples from the C4 dataset (licensed under ODC-BY). Another key parameter is the LoRA rank, which greatly influences the effectiveness of the EoRA adapter. Its optimal value depends on the model architecture, the target task, and the calibration data. A higher rank may yield better performance but risks overfitting to the calibration set. It also increases the size of the adapter, counterproductive when the overall goal of quantization is to reduce memory usage. Conversely, a lower rank keeps the adapter lightweight but might not capture enough information to effectively compensate for quantization errors. In my experiments, I tested LoRA ranks of 32, 64, and 256. Below is the code used to create the EoRA adapter with GPTQModel: from gptqmodel import GPTQModel from gptqmodel.adapter.adapter import Lora from datasets import load_dataset calibration_dataset = load_dataset( "allenai/c4", data_files="en/c4-train.00001-of-01024.json.gz", split="train", download_mode="force_redownload" ).select(range(1024))["text"] eora_adapter_path = "Qwen3-32B-autoround-2bit-gptq-r256" model_path = "kaitchup/Qwen3-32B-autoround-2bit-gptq" eora = Lora( path=eora_adapter_path, rank=256, ) GPTQModel.adapter.generate( adapter=eora, model_id_or_path="Qwen/Qwen3-32B", quantized_model_id_or_path=model_path, calibration_dataset=calibration_dataset, calibration_dataset_concat_size=0, auto_gc=False) Using an NVIDIA A100 GPU on RunPod (referral link), it took approximately 4 hours to generate the EoRA adapter for the model Qwen3-32B-autoround-2bit-gptq. All EoRA adapters created for these models are publicly available (Apache 2.0 license): EoRA Adapters for Qwen2.5 and Qwen3 Evaluating EoRA Adapters for 2-bit LLMs Let’s evaluate the effect of the EoRA adapters. Do they improve the accuracy of the 2-bit models? Image by the author It works! The improvements are particularly notable for Qwen3-14B and Qwen3-32B. For instance, applying EoRA to Qwen3-32B, quantized to 2-bit with a group size of 128, resulted in an accuracy gain of nearly 7.5 points. Increasing the LoRA rank, from 32 to 64, also led to improvements, highlighting the impact of rank on performance. EoRA is also effective on larger models like Qwen2.5-72B, though the gains are more modest. Lower-rank adapters showed little to no benefit on this model; it wasn’t until I increased the rank to 256 that significant improvements began to appear. Memory Consumption of EoRA Using the EoRA adapter during inference results in the following increase in memory consumption: Image by the author The overhead is generally negligible. For instance for 2-bit Qwen3-14B, the adapters only add 257 MB and 514 MB to the total model size, with ranks of 32 and 64. With larger ranks, using an EoRA adapter becomes questionable as the total memory consumption may surpass the memory consumption of the same model quantized at a higher precision. For instance, 2-bit Qwen2.5 72B with an EoRA adapter of rank 256 is larger than 3-bit Qwen2.5 72B. Note: This estimate includes only the memory consumed by the adapter’s parameters. For completeness, we could also account for the memory used by adapter activations during inference. However, these are extremely small relative to other tensors (such as the model’s attention and MLP layers) and can safely be considered negligible. Conclusion EoRA works. We’ve confirmed that it’s a simple yet effective method for compensating quantization errors, even at 2-bit precision. It’s intuitive, training-free, and delivers meaningful performance gains. That said, there are a few trade-offs to consider: Rank search: Finding the optimal LoRA rank requires experimentation. It’s difficult to predict in advance whether a rank of 32 will be sufficient or whether a higher rank, like 256, will cause overfitting. The optimal value depends on the model, calibration data, and target task. Increased memory consumption: The goal of quantization is to reduce memory usage, often for highly constrained environments. While EoRA adapters are relatively lightweight at lower ranks, they do slightly increase memory consumption, particularly at higher ranks, reducing the overall efficiency of 2-bit quantization. Looking ahead, NVIDIA’s paper also demonstrates that EoRA adapters make excellent starting points for QLoRA fine-tuning. In other words, if you plan to fine-tune a 2-bit model using QLoRA, initializing from an EoRA-adapted model can lead to better results with less training effort. I’ve written about fine-tuning adapters for GPTQ model last year, in my newsletter: QLoRA with AutoRound: Cheaper and Better LLM Fine-tuning on Your GPU The main difference is that instead of initializing the adapter from scratch, we would load the EoRA adapter. This adapter will be fine-tuned. References [1] Dettmers et al, QLoRA: Efficient Finetuning of Quantized LLMs (2023), arXiv [2] Badri and Shaji, Towards 1-bit Machine Learning Models (2024), Mobius Labs’ Blog [3] Liu et al., EoRA: Training-free Compensation for Compressed LLM with Eigenspace Low-Rank Approximation (2024), arXiv The post Boost 2-Bit LLM Accuracy with EoRA appeared first on Towards Data Science.

YouTube made its pitch to advertisers on Wednesday, accompanied by a flashy performance from Lady Gaga and special appearances from popular YouTubers like Brittany Broski and MrBeast.  During its Upfront presentation, YouTube executives introduced new ad formats coming to the platform, including an enhanced shoppable connected TV (CTV) offering that includes a new interactive product feed. The move is strategic for YouTube, as it recognizes that viewers often watch videos on the big screen while also using their phones to scroll through social media or shop online. The new shoppable format allows advertisers to display products on the right side of the TV screen during ads. The interactive feed acts as a storefront for brands where viewers can easily browse multiple products using their remotes. When a viewer selects an item, they’re prompted to scan a QR code with their smartphone to get a direct link for purchase.   Additionally, there’s a button for viewers to press and hold, allowing them to send the link to their phones to shop for all the products at once.  Image Credits:YouTube YouTube has become a dominant force in TV viewing. Nielsen reported that it has been the top platform for streaming watch time in the U.S. for over two years, surpassing streaming giants Netflix, Disney+, and Prime Video. In the first quarter of 2025, TVs were the primary device for YouTube viewing in the U.S., according to internal data from the company. Notably, the company pointed to a Kantar survey, indicating that U.S. participants ranked YouTube as the No. 1 platform for seeking out information about brands. The company also said YouTube campaigns on CTV generated over 50 million monthly average conversions in the fourth quarter. Techcrunch event Join us at TechCrunch Sessions: AI Secure your spot for our leading AI industry event with speakers from OpenAI, Anthropic, and Cohere. For a limited time, tickets are just $292 for an entire day of expert talks, workshops, and potent networking. Exhibit at TechCrunch Sessions: AI Secure your spot at TC Sessions: AI and show 1,200+ decision-makers what you’ve built — without the big spend. Available through May 9 or while tables last. Berkeley, CA | June 5 REGISTER NOW Shoppable ads have gained traction among streaming services and advertisers in recent years. Just this week, Amazon announced a new interactive shoppable ad format on Prime Video that highlights Amazon deals, user reviews, and Prime shipping details.

The saying goes that 80% of data collected, stored and maintained by governments can be associated with geographical locations. Although never empirically proven, it illustrates the importance of location within data. Ever growing data volumes put constraints on systems that handle geospatial data. Common Big Data compute engines, originally designed to scale for textual data, need adaptation to work efficiently with geospatial data — think of geographical indexes, partitioning, and operators. Here, I present and illustrate how to utilize the Microsoft Fabric Spark compute engine, with the natively integrated ESRI GeoAnalytics engine# for geospatial big data processing and analytics. The optional GeoAnalytics capabilities within Fabric enable the processing and analytics of vector-type geospatial data, where vector-type geospatial data refers to points, lines, polygons. These capabilities include more than 150 spatial functions to create geometries, test, and select spatial relationships. As it extends Spark, the GeoAnalytics functions can be called when using Python, SQL, or Scala. These spatial operations apply automatically spatial indexing, making the Spark compute engine also efficient for this data. It can handle 10 extra common spatial data formats to load and save data spatial data, on top of the Spark natively supported data source formats. This blog post focuses on the scalable geospatial compute engines as has been introduced in my post about geospatial in the age of AI. Demonstration explained Here, I demonstrate some of these spatial capabilities by showing the data manipulation and analytics steps on a large dataset. By using several tiles covering point cloud data (a bunch of x, y, z values), an enormous dataset starts to form, while it still covers a relatively small area. The open Dutch AHN dataset, which is a national digital elevation and surface model, is currently in its fifth update cycle, and spans a period of nearly 30 years. Here, the data from the second, third, and forth acquisition is used, as these hold full national coverage (the fifth just not yet), while the first version did not include a point cloud release (only the derivative gridded version). Another Dutch open dataset, namely building data, the BAG, is used to illustrate spatial selection. The building dataset contains the footprint of the buildings as polygons. Currently, this dataset holds more than 11 million buildings. To test the spatial functions, I use only 4 AHN tiles per AHN version. Thus in this case, 12 tiles, each of 5 x 6.25 km. Totalling to more than 3.5 billion points within an area of 125 square kilometers. The chosen area covers the municipality of Loppersum, an area prone to land subsidence due to gas extraction. The steps to take include the selection of buildings within the area of Loppersum, selecting the x,y,z-points from the roofs of the buildings. Then, we bring the 3 datasets into one dataframe and do an extra analysis with it. A spatial regression to predict the expected height of a building based on its height history as well as the history of the buildings in its direct surroundings. Not necessarily the best analysis to perform on this data to come to actual predictions* but it suits merely the purpose of demonstrating the spatial processing capabilities of Fabric’s ESRI GeoAnalytics. All the below code snippets are also available as notebooks on github. Step 1: Read data Spatial data can come in many different data formats; we conform to the geoparquet data format for further processing. The BAG building data, both the footprints as well as the accompanied municipality boundaries, come in geoparquet format already. The point cloud AHN data, version 2, 3 and 4, however, comes as LAZ file formats — a compressed industry standard format for point clouds. I have not found a Spark library to read LAZ (please leave a message in case there is one), and created a txt file, separately, with the LAStools+ first. # ESRI - FABRIC reference: https://developers.arcgis.com/geoanalytics-fabric/ # Import the required modules import geoanalytics_fabric from geoanalytics_fabric.sql import functions as ST from geoanalytics_fabric import extensions # Read ahn file from OneLake # AHN lidar data source: https://viewer.ahn.nl/ ahn_csv_path = "Files/AHN lidar/AHN4_csv" lidar_df = spark.read.options(delimiter=" ").csv(ahn_csv_path) lidar_df = lidar_df.selectExpr("_c0 as X", "_c1 as Y", "_c2 Z") lidar_df.printSchema() lidar_df.show(5) lidar_df.count() The above code snippet& provides the below results: Now, with the spatial functions make_point and srid the x,y,z columns are transformed to a point geometry and set it to the specific Dutch coordinate system (SRID = 28992), see the below code snippet&: # Create point geometry from x,y,z columns and set the spatial refrence system lidar_df = lidar_df.select(ST.make_point(x="X", y="Y", z="Z").alias("rd_point")) lidar_df = lidar_df.withColumn("srid", ST.srid("rd_point")) lidar_df = lidar_df.select(ST.srid("rd_point", 28992).alias("rd_point"))\ .withColumn("srid", ST.srid("rd_point")) lidar_df.printSchema() lidar_df.show(5) Building and municipality data can be read with the extended spark.read function for geoparquet, see the code snippet&: # Read building polygon data path_building = "Files/BAG NL/BAG_pand_202504.parquet" df_buildings = spark.read.format("geoparquet").load(path_building) # Read woonplaats data (=municipality) path_woonplaats = "Files/BAG NL/BAG_woonplaats_202504.parquet" df_woonplaats = spark.read.format("geoparquet").load(path_woonplaats) # Filter the DataFrame where the "woonplaats" column contains the string "Loppersum" df_loppersum = df_woonplaats.filter(col("woonplaats").contains("Loppersum")) Step 2: Make selections In the accompanying notebooks, I read and write to geoparquet. To make sure the right data is read correctly as dataframes, see the following code snippet: # Read building polygon data path_building = "Files/BAG NL/BAG_pand_202504.parquet" df_buildings = spark.read.format("geoparquet").load(path_building) # Read woonplaats data (=municipality) path_woonplaats = "Files/BAG NL/BAG_woonplaats_202504.parquet" df_woonplaats = spark.read.format("geoparquet").load(path_woonplaats) # Filter the DataFrame where the "woonplaats" column contains the string "Loppersum" df_loppersum = df_woonplaats.filter(col("woonplaats").contains("Loppersum")) With all data in dataframes it becomes a simple step to do spatial selections. The following code snippet& shows how to select the buildings within the boundaries of the Loppersum municipality, and separately makes a selection of buildings that existed throughout the period (point cloud AHN-2 data was acquired in 2009 in this region). This resulted in 1196 buildings, out of the 2492 buildings currently. # Clip the BAG buildings to the gemeente Loppersum boundary df_buildings_roi = Clip().run(input_dataframe=df_buildings, clip_dataframe=df_loppersum) # select only buildings older then AHN data (AHN2 (Groningen) = 2009) # and with a status in use (Pand in gebruik) df_buildings_roi_select = df_buildings_roi.where((df_buildings_roi.bouwjaar<2009) & (df_buildings_roi.status=='Pand in gebruik')) The three AHN versions used (2,3 and 4), further named as T1, T2 and T3 respectively, are then clipped based on the selected building data. The AggregatePoints function can be utilized to calculate, in this case from the height (z-values) some statistics, like the mean per roof, the standard deviation and the number of z-values it is based upon; see the code snippet: # Select and aggregrate lidar points from buildings within ROI df_ahn2_result = AggregatePoints() \ .setPolygons(df_buildings_roi_select) \ .addSummaryField(summary_field="T1_z", statistic="Mean", alias="T1_z_mean") \ .addSummaryField(summary_field="T1_z", statistic="stddev", alias="T1_z_stddev") \ .run(df_ahn2) df_ahn3_result = AggregatePoints() \ .setPolygons(df_buildings_roi_select) \ .addSummaryField(summary_field="T2_z", statistic="Mean", alias="T2_z_mean") \ .addSummaryField(summary_field="T2_z", statistic="stddev", alias="T2_z_stddev") \ .run(df_ahn3) df_ahn4_result = AggregatePoints() \ .setPolygons(df_buildings_roi_select) \ .addSummaryField(summary_field="T3_z", statistic="Mean", alias="T3_z_mean") \ .addSummaryField(summary_field="T3_z", statistic="stddev", alias="T3_z_stddev") \ .run(df_ahn4) Step 3: Aggregate and Regress As the GeoAnalytics function Geographically Weighted Regression (GWR) can only work on point data, from the building polygons their centroid is extracted with the centroid function. The 3 dataframes are joined to one, see also the notebook, and it is ready to perform the GWR function. In this instance, it predicts the height for T3 (AHN4) based on local regression functions. # Import the required modules from geoanalytics_fabric.tools import GWR # Run the GWR tool to predict AHN4 (T3) height values for buildings at Loppersum resultGWR = GWR() \ .setExplanatoryVariables("T1_z_mean", "T2_z_mean") \ .setDependentVariable(dependent_variable="T3_z_mean") \ .setLocalWeightingScheme(local_weighting_scheme="Bisquare") \ .setNumNeighbors(number_of_neighbors=10) \ .runIncludeDiagnostics(dataframe=df_buildingsT123_points) The model diagnostics can be consulted for the predicted z value, in this case, the following results were generated. Note, again, that these results cannot be used for real world applications as the data and methodology might not best fit the purpose of subsidence modelling — it merely shows here Fabric GeoAnalytics functionality. R20.994AdjR20.981AICc1509Sigma20.046EDoF378 Step 4: Visualize results With the spatial function plot, results can be visualized as maps within the notebook — to be used only with the Python API in Spark. First, a visualization of all buildings within the municipality of Loppersum. # visualize Loppersum buildings df_buildings.st.plot(basemap="light", geometry="geometry", edgecolor="black", alpha=0.5) Here is a visualization of the height difference between T3 (AHN4) and T3 predicted (T3 predicted minus T3). # Vizualize difference of predicted height and actual measured height Loppersum area and buildings axes = df_loppersum.st.plot(basemap="light", edgecolor="black", figsize=(7, 7), alpha=0) axes.set(xlim=(244800, 246500), ylim=(594000, 595500)) df_buildings.st.plot(ax=axes, basemap="light", alpha=0.5, edgecolor="black") #, color='xkcd:sea blue' df_with_difference.st.plot(ax=axes, basemap="light", cmap_values="subsidence_mm_per_yr", cmap="coolwarm_r", vmin=-10, vmax=10, geometry="geometry") Summary This blog post discusses the significance of geographical data. It highlights the challenges posed by increasing data volumes on Geospatial data systems and suggests that traditional big data engines must adapt to handle geospatial data efficiently. Here, an example is presented on how to use the Microsoft Fabric Spark compute engine and its integration with the ESRI GeoAnalytics engine for effective geospatial big data processing and analytics. Opinions here are mine. Footnotes # in preview * for modelling the land subsidence with much higher accuracy and temporal frequency other approaches and data can be utilized, such as with satellite InSAR methodology (see also Bodemdalingskaart) + Lastools is used here separately, it would be fun to test the usage of Fabric User data functions (preview), or to utilize an Azure Function for this purpose. & code snippets here are set up for readability, not necessarily for efficiency. Multiple data processing steps could be chained. References GitHub repo with notebooks: delange/Fabric_GeoAnalytics Microsoft Fabric: Microsoft Fabric documentation – Microsoft Fabric | Microsoft Learn ESRI GeoAnalytics for Fabric: Overview | ArcGIS GeoAnalytics for Microsoft Fabric | ArcGIS Developers AHN: Home | AHN BAG: Over BAG – Basisregistratie Adressen en Gebouwen – Kadaster.nl zakelijk Lastools: LAStools: converting, filtering, viewing, processing, and compressing LIDAR data in LAS and LAZ format Surface and Object Motion Map: Bodemdalingskaart – The post The Geospatial Capabilities of Microsoft Fabric and ESRI GeoAnalytics, Demonstrated appeared first on Towards Data Science.

Author(s): Felix Pappe Originally published on Towards AI. Image created by the author using gpt-image-1 Introduction In the past, extracting specific information from documents or images using traditional methods could have become quickly cumbersome and frustrating, especially when the final results stray far from what you intended. The reasons for this can be diverse, ranging from overly complex document layouts to improperly formatted files, or an avalanche of visual elements, which machines struggle to interpret. However, vision-enabled language (vLMs)models have come to the rescue. Over the past months and years, these models have gained ever-greater capabilities, from rough image descriptions to detailed text extraction. Notably, the extraction of complex textual information from images has seen astonishing progress. This allows for rapid knowledge extraction from diverse document types without brittle, rule-based systems that break as soon as the document structure changes — and without the time-, data-, and cost-intensive specialized training of custom models. However, there is one flaw: vLMs, like their text-only counterparts, tend to produce verbose output around the information you actually want. Phrases such as “Of course, here is the information you requested” or “This is the extracted information about XYZ” commonly surround the essential content. You could use regular expressions together with advanced prompt engineering to constrain the vLM to output only the requested information. However, crafting the perfect prompt and matching regex for a given task is difficult and requires much trial and error. In this blog post, I’d like to introduce a simpler approach: combining the rich capabilities of vLLMs with the strict validation offered by Pydantic classes to extract exactly the desired information for your document processing pipeline. Description of post tackled issue The example in this blog post describes a situation that every job applicant has likely experienced many times. I am sure of it. After you have carefully and thoroughly created your CV, thinking about every word and maybe even every letter, you upload the file to a job portal. But after successfully uploading the file, including all the requested information, you are asked once again to fill out the same details in standard HTML forms by copying and pasting the information from your CV into the correct fields.Some companies attempt to autofill these fields based on the information extracted from your CV, but the results are often far from accurate or complete.In the following code, I combine Pixtral, LangChain, and Pydantic to provide a simple solution. The code extracts the first name, last name, phone number, email, and birthday from the CV if they exist. This helps keep the example simple and focuses on the technical aspects.The code can be easily adapted for other use cases or extended to extract all required information from a CV.So let us dive into the code. Code walkthrough Importing required libraries In the first step, the required libraries are imported, including: os, pathlib, and typing for standard Python modules providing filesystem access and type annotations base64 dontenv.env file into os.environ pydanticLLM output ChatMistralAILLM interface PIL import osimport base64from pathlib import Pathfrom typing import Optionalfrom dotenv import load_dotenvfrom pydantic import BaseModel, Fieldfrom langchain_mistralai.chat_models import ChatMistralAIfrom langchain_core.messages import HumanMessagefrom PIL import Image Loading environment variables Subsequently, the environment variables are loaded using load_dotenv(), and the MISTRAL_API_KEY is retrieved. load_dotenv()MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")if not MISTRAL_API_KEY: raise ValueError("MISTRAL_API_KEY not set in environment") Defining the output schema with pydantic Following that, the output schema is defined using Pydantic. Pydantic is a Python library for data parsing and validation based on Python type hints. At its core, Pydantic’s BaseModel offers various useful features, such as the declaration of data types (e.g. str, int, List[str], nested models, etc.) and automatic coercion of incoming data into the required types when possible (e.g., converting "102" into 102). Moreover, it validates whether the incoming data matches the predefined schema and raises an error if it does not. Thanks to these clearly defined schemas, the data can be quickly serialized into other formats such as JSON. Likewise, Pydantic also allows the creation of document fields with metadata that tools such as LLMs can inspect and utilize. The next code block defines the structure of the expected output using Pydantic. These are the data points that the model should extract from the CV image.class BasicCV(BaseModel): first_name: Optional[str] = Field(None, description="first name") last_name: Optional[str] = Field(None, description="last name") phone: Optional[str] = Field(None, description="Telephone number") email: Optional[str] = Field(None, description="Email address") birthday: Optional[str] = Field(None, description="Date of birth (e.g., YYYY-MM-DD)") Converting images to base64 Subsequently, the first function is defined for the script. The function encode_image_to_base64() does exactly what its name suggests. It loads an image and converts it into a base64 string, which is passed into the vLM later. Moreover, an upscaling factor has been integrated. Although no additional information is gained by simply increasing the height and width, in my experience, the results tend to improve, especially in situations where the original resolution of the image is low. def encode_image_to_base64(image_path: Path, upscale_factor: float = 1.0) -> str: with Image.open(image_path) as img: if upscale_factor != 1.0: new_size = (int(img.width * upscale_factor), int(img.height * upscale_factor)) img = img.resize(new_size, Image.LANCZOS) from io import BytesIO buffer = BytesIO() img.save(buffer, format="PNG") image_bytes = buffer.getvalue() return base64.b64encode(image_bytes).decode() Processing the CV with a vision language model Now, let’s move on to the main function of this script. The process_cv() function begins by initializing the Mistral interface using a previously generated API key. This model is then wrapped using the .with_structured_output(BasicCV) function, in which the Pydantic model defined above is passed as input. If you are using a different vLM, make sure that it supports structured output, as not all vLMs do. Afterwards, the input image is converted into a base64 (b64) string, which is then transformed into a Uniform Resource Identifier (URI) by attaching a metadata string in front of the b64 string. Next, a simple system prompt is defined, which leaves room for improvement in more complex extraction tasks but works perfectly for this scenario. Finally, the URI and system prompt are combined into a LangChain HumanMessage, which is passed to the structured vLM. The model then returns the requested information in the previously defined Pydantic format. def process_cv() -> BasicCV: image_path: Path, api_key: Optional[str] = None llm = ChatMistralAI( model="pixtral-12b-latest", mistral_api_key=api_key or MISTRAL_API_KEY, ) structured_llm = llm.with_structured_output(BasicCV) image_b64 = encode_image_to_base64(image_path) data_uri = f"data:image/png;base64,{image_b64}" system_text = ( "Extract only the following fields from this CV: first name, last name, " "telephone number, email address, and birthday. Return JSON matching the schema." ) message = HumanMessage( content=[ {"type": "text", "text": system_text}, {"type": "image_url", "image_url": data_uri}, ] ) result: BasicCV = structured_llm.invoke([message]) return result Running the script This function is executed by the main, where the path is defined and the final information is printed out. if __name__ == "__main__": image_file = Path("cv-test.png") cv_data = process_cv(image_file) print(f"First Name: {cv_data.first_name}") print(f"Last Name: {cv_data.last_name}") print(f"Phone: {cv_data.phone}") print(f"Email: {cv_data.email}") print(f"Birthday: {cv_data.birthday}") Conclusion This simple Python script provides only a first impression of how powerful and flexible vLMs have become. In combination with Pydantic and with the support of the powerful LangChain framework, vLMs can be turned into a meaningful solution for many document processing workflows, such as application processing or invoice handling. What experience have you had with vision Large Language Models? Do you have other fields in mind where such a workflow might be beneficial? Source Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor. Published via Towards AI

Proven experience designing decks, presentations, or marketing materials in Canva.Strong design sensibility with an eye for layout, typography, and color.Ability to transform complex content into visually digestible and engaging formats.Proficient in creating custom graphics, including charts and other visual elements.Detail-oriented and able to refine existing content for clarity and impact.Excellent communication skills to collaborate with the team effectively.

Capcom Vs. SNK 2 – a good old fashioned brawl (Capcom) The latest in Capcom’s series of retro fighting game compilations focuses on Capcom Vs. SNK and GameCentral favourite Power Stone. Every time we talk to anyone from Capcom, no matter what the subject is, we always ask about a new sequel to Power Stone. We’ve been doing it for over a decade now, mostly just to annoy them, but now, finally, the series has returned. We don’t know how many other people are excited about that fact – probably not many, given the length of the franchise’s absence – but we couldn’t be happier. At the same time, it can be a depressing jolt of reality when you return to a game after many years, with memories of its greatness, and realise that time has not been kind to it. Power Stone, and some of the other games in this collection, are over a quarter of a century old but, to our relief, they’re still highly enjoyable today, with that classic Capcom combination of swagger and cheesy exuberance. In fact, it’s remarkable just how well Capcom fighting games tend to endure, as evidenced by the previously released Capcom Fighting Collection and Marvel Vs. Capcom Fighting Collection: Arcade Classics. A cynical mind might accuse this third title of starting to scrape the bottom of the barrel but that’s not fair, as while these games might not be as well known they’re every bit as interesting as Capcom’s more famous headliners. Although it contained a number of unrelated titles, the main focus of the first Capcom Fighting Collection was the Darkstalkers series, with all five original arcade games included. There’s a less clear-cut theme for this one, but the most high-profile inclusions (if you’re a Power Stone philistine) are probably the two Capcom Vs. SNK games. There is something that connects all but one of the games though and that’s that all of them were also ported to the Dreamcast, as everything but Capcom Fighting Evolution was released in a narrow window between 1998 and 2001. That matches up exactly with the life and death of Sega’s last console, of which Capcom was one of the most prolific supporters. That creates a slight problem though, in that all these versions of the games are based on the original coin-ops – which the majority of people will never have played – and not the more familiar Dreamcast editions. That’s a real shame, because a lot of ancillary options have been lost in the process, particularly for something like Power Stone 2, which had an additional Adventure mode involving unlocking extra weapons and items. That’s not to suggest this is a lazy compilation though; like the previous ones it’s anything but. It’s just unfortunately the emphasis is solely on the arcade versions. As such, you get both the English and Japanese versions of each game, plus museum content, in-game achievements, and brand new online options including casual, ranked, and custom matches. Each game also has a new training mode, where the button presses are indicated on-screen; you can pause and restart the single-player modes at any time; and there’s a ton of controller and difficultly level options, including the chance for one button specials. There’s alternative sound mixes too, plenty of screen filter options, and they even bothered to scan in the original arcade marquee cards, that explained how the games work. We’ll go through the games in chronological order, which starts with 3D fighter Plasma Sword: Nightmare Of Bilstein. Probably the most obscure title in the collection, it’s known as Star Gladiator 2 in Japan and is essentially a sci-fi take on Soulcalibur, completely with faux lightsabers. It also shares a lot of DNA with Street Fighter EX but even in 1998 it was considered a generic outing, with sub-par graphics. Although it’s still miles better than contemporary Star Wars: Masters Of Teräs Käs. Power Stone doesn’t necessarily look that great in screenshots (Capcom) The first Power Stone was released in 1999 and we strongly feel it’s one of the most underappreciated fighting games of all time, especially when it comes to the use of 3D space. Instead of just sidling round your opponent you have full freedom of movement in a small 3D arena, using objects, walls, and architecture to increase your attack options, as well as picking up weapons and the titular power stones. Collect all of the latter and you briefly transform into a powered-up form, similar to the Infinity Gem gimmick from Marvel Super Heroes. The downside to this is that there are no real combos, except doing the same attack multiple times, and a very limited number of special moves, but that’s not really the point. What the game loses in technical complexity it gains in terms of tactical intrigue, as you use the stage, and your opponents’ desire to get to a weapon or power stone before you, to your advantage. Admittedly, it’s still not exactly a deep game but the foundation was there to build it into something more complex. As it was though, Capcom went in the opposite direction for Power Stone 2 and while there were a few clones at the time, such as Shrek SuperSlam, the concept sadly just faded away. Which is a real shame because we’ve always felt it would make the perfect template for a new Super Smash Bros., especially after Ultimate left the series with nowhere else to go. 2000’s Power Stone 2 takes the same concept and rather than trying to deepen the combat it turns the crazy up to 11. The four-player brawls occur over larger stages, which often transform during battle, and there’s a much larger range of weapons, as well turrets and even moving vehicles to take control of. With four people who know what they’re doing (which the AI often does not) it’s glorious chaos but unfortunately that’s as far as the concept ever went. If you want a more technical fighter then you need look no further than Capcom Vs. SNK: Millennium Fight 2000 Pro, the first of several crossovers created with publishing rival SNK. SNK made a bunch of Card Fighters Clash games, plus a fighter for the Neo Geo Pocket, and the disappointing SNK Vs. Capcom: SVC Chaos, but it’s Capcom’s two games which are considered the best thing to come out of the team-up. Despite the name, the only non-Street Fighter character from Capcom is Morrigan, while SNK’s line-up is based on The King Of Fighters (which itself is a crossover of various SNK franchises, such as Fatal Fury). You can choose attack meters derived from either Street Fighter Alpha or The King of Fighters ’98, although there were other modes and features in the Dreamcast version. Project Justice, aka Rival Schools 2, is another relative obscurity, at least in the West, but is arguably Capcom’s best 3D fighter (in the non-Power Stone sense of the concept). It’s a 3v3 team fighter but while there’s a lot more depth and complexity to the combat than Plasma Sword it still comes across as a little late to the party, compared to something like Tekken – which had been around for six years at this point. The lone Street Fighter game in the collection is Street Fighter Alpha 3 Upper, which is a bit of a random pick but a very well regarded entry and the last in the Alpha sub-series of prequel titles. The pixel graphics are great and the introduction of the different ‘-ism’ fighting styles went on to have quite an impact on Capcom fighting games in general. Power Stone aside, Capcom Vs. SNK 2: Mark Of The Millennium 2001 is the star of the collection, with a much larger selection of characters than the original, although the number of non-Street Fighter characters is still frustratingly small. More Trending The system for selecting your team is one of the biggest gameplay changes, with a ratio system that limits the selection according to the character’s power and not just how many fighters there are – which, again, went on to influence many future games. 2004’s Capcom Fighting Evolution (aka Capcom Fighting Jam) is the most recent entry in the collection but easily the least interesting. It’s a very half-hearted crossover fighter, featuring characters from Street Fighter, Darkstalkers, and Red Earth. It barely even scratches the surface of the Capcom Vs. Capcom game that fans have long yearned for, with sprites stolen from Capcom Vs. SNK 2 – except with simplified animation and a lot of missing moves. Despite the odd dud game, all of these fighting collections have been great and while it does depend to a degree on how much nostalgia you have for the titles, most of them are significant in some way – and we’d dearly like to see new entries in the Power Stone and Capcom Vs. SNK series. The missing Dreamcast versions are a real shame but even without that Capcom Fighting Collection 2 is a fascinating and sensibly priced compilation, that has clearly been produced with a lot of love and effort. Capcom Fighting Collection 2 review summary In Short: Another excellent compilation of forgotten Capcom fighters, with the revival of Power Stone and Capcom Vs. SNK being especially welcome – even if it’s a shame these aren’t the Dreamcast versions. Pros: Almost all the games are interesting and enjoyable, while the range of new options, including fully featured online, training modes, and difficulty and display options are top notch. Cons: It’s a real shame that the Dreamcast versions aren’t included, as they had a lot of extra content and modes. Capcom Fighting Evolution is rubbish. Score: 8/10 Formats: PlayStation 4 (reviewed), Xbox One, Nintendo Switch, and PCPrice: £34.99Publisher: CapcomDeveloper: CapcomRelease Date: 16th May 2025Age Rating: 16 Project Justice is an interesting curio (Capcom) Email gamecentral@metro.co.uk, leave a comment below, follow us on Twitter, and sign-up to our newsletter. To submit Inbox letters and Reader’s Features more easily, without the need to send an email, just use our Submit Stuff page here. For more stories like this, check our Gaming page. GameCentral Sign up for exclusive analysis, latest releases, and bonus community content. This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply. Your information will be used in line with our Privacy Policy

Key Takeaways A bill has been introduced that plans to verify the ownership and location of regulated processors and advanced AI tech. This would require companies like Nvidia, AMD, and Intel to embed location tracking functions into regulated products. This bold move appears highly questionable and could have long-term consequences on global trade. The US is planning to introduce legislation that would make it mandatory for manufacturers of high-performance AI processors to add geographical location tracking to their products. This is reportedly being done to stop advanced AI components from falling into the hands of China.  Remember, the US government has already placed several export restrictions on advanced AI chips, including Nvidia’s H100 and A100. However, this geographical tracking takes things a notch higher. As per reports, US officials are worried about increasing instances of AI tech smuggling, which means these chips ultimately end up in China in one way or another. The recently launched Hunyuan-Large AI model was also reportedly trained on Nvidia H20 GPUs, which are export-controlled. This reconfirms America’s fear of China using illegal channels to source these chips. This is why Senator Tom Cotton of Arkansas has introduced a bill that would allow the Commerce Secretary to impose location controls on these companies. The bill covers high-performance AI processors, including the GeForce RTX 4090 and RTX 5090, as well as other AI chips. The companies will be required to embed tracking technology in all high-end processor modules, including products that have already been developed. Companies will have six months to comply with these requirements after the bill is enacted. The US also suspects that China might procure these restricted chips from other export-free countries on the US list. That is why the bill aims to meticulously verify the ownership and location of regulated processors. In a nutshell, the US government has banned the export of certain products to China, and the products that are allowed to be exported will now be embedded with live location tracking. Location Tracking Might Be a Bit of an Overkill If this bill comes into force, a one-year study will be conducted jointly by the Department of Commerce and the Department of Defense to explore additional protective measures. The departments will also conduct annual assessments for three years after the bill becomes law. If the additional measures are considered appropriate, the Department of Commerce will work on them to finalize rules within the next two years. This means location tracking isn’t really the final nail in the coffin. The US might be planning to launch more such control measures in the next few years. While one can understand the rationale behind tracking the location of each US-made chip, this seems to be a bit of overkill. After all, such a ‘dictatorship’ move can be detrimental to free trade in the technology space. Companies like Nvidia, AMD, and Intel will have to spend billions to incorporate this technology, and even after that, they will have little control over whom they can sell to. It’s as good as the government tightening its control on these companies, which are essentially becoming playthings for the US government in the overall global foreign trade policy. Today, the US has a problem with China, so it’s implementing such draconian measures. Tomorrow, if there is a conflict between the US and the UK or the US and the EU, who’s to say that the government will not use this law to twist arms? Nvidia is expected to be hit the hardest. 13% of Nvidia’s total sales come from China, which is around $17 billion as of January 2025. Plus, the tech giant is already sitting on orders worth $18B in the current year. Image Credit – Finchat_io on Threads Furthermore, the company is already planning to export a downgraded version of the H20 chip with lower computing power, which will fall outside the purview of the proposed export controls. However, the US might very well block this move or require location tracking on these chips as well. Another issue with the proposed bill is the time period of the tracking. When does it stop? Does it stop at all? This could result in massive privacy scares, as retail customers using these trackable, tech-embedded products would, at all times, have their location exposed to the US authorities.  US Export Regulations Are in a Mess The US export policy is currently as confusing as it has ever been. With arbitrary tariff rate increases, export bans, and now location tracking, the US is leaving no stone unturned to ensure artificial intelligence supremacy. However, this is based on the assumption that China is totally reliant on the US for AI development, which is far from the truth. For instance, Huawei’s 910C GPU offers the same level of performance as Nvidia’s H100, which was released in 2022. To put it simply, China seems to be just three years behind the US when it comes to AI technology. Nvidia CEO Jensen Huang has also said that China is very close to the US. Plus, now that China has finally started to produce US-comparable chips, it may start catering to the global chip market and export its homemade AI chips to other countries. In that case, these strict regulations may backfire on the US, and it may end up losing a sizable chunk of the global market to China. So, this begs the question of whether such an extensive and restrictive export policy is actually needed. We have already seen how DeepSeek was built for a fraction of the cost of other AI models. So, China may catch up with the US sooner than expected. For now, we’ll wait to see if and when this bill comes into force. The concerned companies may also put forward their reservations, and clauses may be worked out before being set into writing. Krishi is a seasoned tech journalist with over four years of experience writing about PC hardware, consumer technology, and artificial intelligence.  Clarity and accessibility are at the core of Krishi’s writing style. He believes technology writing should empower readers—not confuse them—and he’s committed to ensuring his content is always easy to understand without sacrificing accuracy or depth. Over the years, Krishi has contributed to some of the most reputable names in the industry, including Techopedia, TechRadar, and Tom’s Guide. A man of many talents, Krishi has also proven his mettle as a crypto writer, tackling complex topics with both ease and zeal. His work spans various formats—from in-depth explainers and news coverage to feature pieces and buying guides.  Behind the scenes, Krishi operates from a dual-monitor setup (including a 29-inch LG UltraWide) that’s always buzzing with news feeds, technical documentation, and research notes, as well as the occasional gaming sessions that keep him fresh.  Krishi thrives on staying current, always ready to dive into the latest announcements, industry shifts, and their far-reaching impacts.  When he's not deep into research on the latest PC hardware news, Krishi would love to chat with you about day trading and the financial markets—oh! And cricket, as well. View all articles by Krishi Chowdhary Our editorial process The Tech Report editorial policy is centered on providing helpful, accurate content that offers real value to our readers. We only work with experienced writers who have specific knowledge in the topics they cover, including latest developments in technology, online privacy, cryptocurrencies, software, and more. Our editorial policy ensures that each topic is researched and curated by our in-house editors. We maintain rigorous journalistic standards, and every article is 100% written by real authors.

Netflix has more than doubled the number of people watching its ad-supported tier over the last year. At its upfront presentation for advertisers on Wednesday, the company revealed that the $7.99 per month plan now reaches more than 94 million users around the world each month – a big increase from the 40 million it reported in 2024 and the 70 million it revealed last November. The streaming giant’s ad tier has seen rapid growth since its debut in 2022. As the service grows more comfortable with ads, it’s getting ready to debut more formats by the end of 2026, including pause ads, which it first started experimenting with last year, and interactive ads that appear in the middle of what you’re watching. Netflix stopped reporting how many total subscribers it adds each quarter, but it last said it had over 300 million globally in January. Amy Reinhard, Netflix’s president of advertising, said the streaming service has “the most engaged audience anywhere,” with subscribers on its ad-supported tier spending an average of 41 hours per month on the service. The new ad formats are part of Netflix’s in-house advertising platform, which is now live in the US after arriving in Canada. It plans to bring the platform to all 12 countries with ad-supported plans by June. “The foundations of our ads business are in place,” Reinhard said. “And going forward, the pace of progress will be even faster.”