Random Musings from Jay Myers

Creating Machine-explorable Product Categories Using RDFa and SKOS

Jay — Wed, 09 Jun 2010 16:13:05 +0000

If haven’t guessed it already, I’m a big fan of the GoodRelations vocabulary as a solid way to describe products, product offers and shop locations. However, most SemWeb vocabularies have some sort of logical limit — for scalability and pure practicality, most don’t include every single data attribute that could possibly describe the object they are annotating. To create complete semantic solutions, you usually start to combine various ontologies.

As complete as GoodRelations is, I have been searching for a way to annotate product types/ categories with it. Product categories can be unique to retailer/ manufacturer, and with billions of consumer products and endless numbers of product categories, universal product categorization seems to be an unreachable goal. I have seen a few attempts at mass product categorization, but I haven’t seen a ton of progress (who would want to manage a massive global product taxonomy?!). Furthermore, getting consensus on category definitions seems like a futile effort that should really be avoided.

However, just because there aren’t any universal standards out there doesn’t mean we can’t start giving machines a shot at some semblance of product categorization. We can begin to provide definitions to product categories by annotating our HTML with RDFa and SKOS (along with other vocabs like GoodRelations).

There are a couple of initial use cases I have identified:

Parsing navigation to capture general product hierarchies

As retailers, we should want to let the world know what kind of products we sell. In my day to day duties, I’m always surprised at what type of products I uncover on our site (especially during project QA!). With around 650,000 active SKUs on any given day, there is much to explore. Of course this is a nearly impossible task for a human to do, so it makes sense to expose these rich data points in our HTML using RDFa and let the parsers do the work for us. This data is not only useful for external consumption, but internal as well. Throughout the ecommerce world there is also significant human effort dedicated to updating and maintaining product taxonomies — many organizations have entire teams dedicated to this activity. What if we could rely on smart machines to perform this function and make “recommendations”? My experience tells me there would be a whole lot less bickering in the workplace.

Enough of the justification, here’s an example and code snippet to ponder:

Faceted commerce navigation example


	Shop TV & Video
	
		TVs
		Projectors & Screens
		Blu-ray & DVD Players
		Home Theater Systems
		TiVo & Internet TV
		Digital TV Converters
		DIRECTV, Cable & Fiber Optics TV
		Stands, Mounts & Furniture
		Portable TV & Video
		TV & Home Theater Services
		TV & Video Accessories

Assigning product categories through product detail page “breadcrumbs” with SKOS and GoodRelations

As I mentioned previously, I have been searching for a good way to annotate product categories/ types with GoodRelations. A common practice on commerce sites is the utilization of breadcrumbs — as a visual reminder of where you are in the shopping experience. We can annotate these breadcrumbs with SKOS in the domain of GoodRelations (child of gr:includesObject) to completely categorize a product, building a product category hierarchy from top-level category down to more narrow child categories.

Example and code:

Best Buy local store open box detail page with breadcrumbs


	
		
			Best Buy
			TV & Video
			TVs
			All Flat-Panel TVs
			Product Info

Full HTMLs for your perusal: facted-nav-skos.html, gr-skos-breadcrumb.html

Creating Local Visibility to Open Box Products with Front-End Semantic Web

Jay — Tue, 30 Mar 2010 19:38:24 +0000

Let’s face the facts, it’s a tough job to be a retailer these days. Competition is fierce, customers are demanding, and product margins are razor thin. Just when retailers finally get that product into a customers hand and out the door, it can come marching right back into the store as a return. In fact, studies estimate there are tens of billions of dollars worth of product returned back to retailers, and very small percentage of those are actually defective. This means that brick and mortar retailers have plenty of fully functional open box products gathering dust on shelves and are missing an opportunity to get these units back into the hands of customers.

All of our local Best Buy stores are challenged with returned products. Our physical stores can be silos of beneficial product data, especially when it comes to the availability and reduced price scenarios presented by open box products. Up to this point, our open box items have not been openly displayed on the web — we tend to focus on new, unopened products, leaving an huge unmet opportunity at the store level to increase web visibility to returned products.

While this seems like a large problem to tackle, we have found a forward-thinking way to increase the visibility of open box items at our local stores using the power of open source software and open front-end semantic data standards without employing traditional marketing tactics to push individuals toward these products. Earlier this month, we began rolling out the capability for store associates to contribute to the web of data while increasing visibility to their local open box products through a simple WordPress plugin and RDFa templating mechanism. Each Best Buy store is empowered via their local store WordPress blog (background here) to enter the SKUs of the open box products they have in their inventory. The plugin fetches the relevant product data using Best Buy’s Remix API and the user is prompted to enter the open box price and a reason the product was returned. With one last click, the user saves the data and the product is published to the store site, is made available to the semantic web through front-end RDFa templates and auto-generated XML sitemaps.

There are some interesting features, techniques and potential outcomes of this work that are worth discussing:

Utilizing GoodRelations product vocabulary with RDFa. If you are currently looking for a semantic way to expose your products, store locations, store hours, etc., GoodRelations is fast becoming the ontology of choice. Combining this with RDFa markup (or microdata?) creates rich data and visual experiences over the web, enabling webmasters to contribute to the web of data via their rich HTML, and parsers/ machines to glean data directly from a customer facing web site. Could RDFa or microdata become an authoritative source for visual consumption by humans AND data consumption by machines for things like consumer goods and services?

Cool/ clean permanent URIs. It’s a fairly common SEO practice to create descriptive URIs with things like object names, categories, or special character escaped product titles in them. We have mimicked this practice in our URIs, recognizing that this entity is a product, its condition is “open box”, and highlighting the product title:

http://stores.bestbuy.com/577/fairless-hills-pa/products/open-box/frigidaire-30-freestanding-range/0012505540066/?uid=118

Our technique for open box products also takes it a bit further, as these products are unique to a single Best Buy store and have a specific open box price that may differ from other units with the same SKU or UPC. One desire of this project was narrowing the scope of these unique items to the local level, as they are only available for purchase in store. One way we have attempted to solve for this is putting the store number, plain text location, and a unique product identifier in the URI:

http://stores.bestbuy.com/577/fairless-hills-pa/products/open-box/frigidaire-30-freestanding-range/0012505540066/?uid=118

Lastly, we’ve decided to break away from proprietary Best Buy catalog conventions and highlight the thirteen digit product EAN (UPC with an additional 0 prepended). Many retailers including Best Buy utilize proprietary catalog or product ids for their commerce platforms, which forces search engines, product comparison engines, and the like to build separate functionality to match the specific retailer’s products, or do additional digging to complete product matching and return relevant results. It would seem the sensible thing to do for retailers (and manufacturers too!) to utilize and expose the UPC/ EAN spec as a sort of “primary key” for products across the web. I’m attempting to lay the groundwork starting with exposure in the URI:

http://stores.bestbuy.com/577/fairless-hills-pa/products/open-box/frigidaire-30-freestanding-range/0012505540066/?uid=118

Creating relationships between the product and where it “lives”. Using the inherent features of linked data and semantic web, we are easily able to establish links between product and store. This is another technique utilized in this project to narrow focus down to a local level. Essentially we are using semantics to say, “I’m a specific product entity available at this permanent URI, where you can discover more about my n attributes. You can locate me at this specific store entity via its URI, where it exposes rich location and hours of operation data to make it easy for you to acquire me.”

Makes semantic web publishing accessible to everyday employees. I believe the semantic web movement still struggles with the chicken/ egg scenario — data publishers may not be creating semantic data because of a perceived lack of applications to parse their data, while application developers may not be actively creating new software to consume and use semantic data. With this simple toolset we have unleashed the power of our workforce to publish extensive local product data sets to the web using open standards, making them accessible to new applications for consumption and parsing.

Low cost of entry, low level of difficulty, potentially high return on investment. While larger enterprises may want to integrate semantics into their enterprise systems, there are ways to start contributing now to the web of data without having to adopt a specific technology platform by simply coding it into your templating engine. Kudos to Drupal, osCommerce Shop Software, Joomla/Virtuemart CMS/Shop combo, and others for including semantics natively or making them available via modules or plugins.

I invite you to see more, test, parse, and make comments or constructive criticism by visiting some of our more active stores. Follow these links to aggregate listing pages and click through to analyze individual product markup:

Unexplored SEO Opportunities Utilizing Semantic/ Structured Web

Jay — Tue, 29 Dec 2009 20:26:11 +0000

There has been a flurry of chatter around the potential impact of RDFa on SEO after my brief presentation at SES Chicago 2009. In subsequent conversations with SEOs at the SES conference and folks from around the industry, I was surprised at how many people practicing SEO weren’t involving their web developers in their solutions, but rather focusing mostly on content, linking and social strategies. While these solutions are key in any SEO activities, the fact that our panel discussion and presentation was the only one involving code and coding techniques surprised me. This raises an interesting question: are many SEOs missing a core element to success, namely well structured, semantically-rich core web sites?

One can look at the current state of HTML on many web sites as an indicator of where people are focusing their efforts. The research performed to create the hProduct Microformat draft spec gives some good insight as to the condition of front-end HTML code. For years we have been building web sites mostly for visual, presentational (human-readable) purposes, and this is clear in many pages of source code analyzed for the hProduct spec. Luckily, search engines have done an incredible job of parsing out the junk and extracting the contextual and important data from billions of web pages. Machines have become vital to helping us learn, but up to this point there has been an imbalance in human-readable vs. machine-readable front-end code. Now there are emerging techniques and technologies that web developers can easily use to correct this by coding their pages to give them meaning to humans AND machines.

By combining rich front-end user and data experiences utilizing RDFa, Microformats, or the emerging Microdata spec, we build direct pathways to rich datasets, which enable machines (mostly search engines, but also next-gen parsers, browser plugins, etc.) to easily access important data and apply their algorithms, etc., to make sense of it all and index it in the ways they see fit. My personal theory is that by providing more direct access to data through front-end semantic code, machines will spend fewer CPU cycles parsing presentational code. These extra resources could then be re-allocated to better natural language processing, extending search into the “deep web”, or other efforts to make the web and it’s users smarter.

Of course this has implications to the SEO/SEM world. It forces SEO professionals to engage their web developers or become slightly more code savvy themselves. It shifts more emphasis on developing strong, data-driven semantic web sites that balance the visual needs of humans and the data needs of machines, rather than focusing on seemingly artificial techniques that increase “link juice” or utilize “secret sauce”. Using traditional SEO content strategies in combination with building strong data-rich web sites can lead to a more intelligent and useful web, which is ultimately good for businesses, users and consumers.

Example Best Buy Product RDFa Markup Released (beta)

Jay — Mon, 26 Oct 2009 15:54:35 +0000

There is a good amount of chatter about the semantic web out there, but not a ton of concrete, working examples. I decided to put our Best Buy data to work and publish BBY SKUs in RDFa, using the GoodRelations e-commerce ontology. As I see it, simply publishing the RDFa is not an issue — the challenge is to apply real-world style and structure to the code to make it both machine and human readable. I’m trying to answer the question: is the RDFa model flexible enough to allow Joe Web Developer to successfully publish valid structured data while satisfying the desires of his design, business, and marketing counterparts?

I’m pleased with the first round of results, ~460K worth of “next-gen” product detail pages. Take a look at some choice example SKUs from the Best Buy product catalog:

Music SKU: http://products.semweb.bestbuy.com/y/products/9312861/
Movies SKU: http://products.semweb.bestbuy.com/y/products/7590289/
Software SKU: http://products.semweb.bestbuy.com/y/products/9509686
Games SKU: http://products.semweb.bestbuy.com/y/products/9346442/
“Hardgoods” SKU: http://products.semweb.bestbuy.com/y/products/8967228/

Interested parties can get a full URL list here (txt, gz), or split up into list 1, list 2, and list 3 (txt).

Thanks to: Martin Hepp, Andreas Radinger, Alex Stolz, Yahoo! Searchmonkey, Jason Galep (design guidance), and Best Buy Remix.

Zompire Dracularius

Jay — Tue, 20 Oct 2009 15:44:01 +0000

I saw an interesting post today via Twitter from a local person hosting an SEO competition to see who gets the highest Google search result for the key words zompire dracularius. I am officially throwing my hat in the ring. Recently I have been investigating how good semantic markup (including RDFa/Microformats) in the front-end will improve or change the way search engines work — basically how POSH (plain old semantic html) delivers data directly to the browser with particular markup. For the purposes of this test I have employed some semantic markup techniques, plus a few other tactics to raise the visibility of my post:

Using RDFa in my posts (dublin core)
Creating a “human readable” URL for this post using permalink structure built into WordPress
Providing links to the original post and other sources (I will attempt to trackback, although no trackback link is published)
Send to social networking sites I participate in — this is done automatically when I publish a post on my blog to Friendfeed, Twitter and Facebook
Attempt to leverage my blog’s overall visibility to force my post about zompire dracularius to the top
Leave a comment on the original blog declaring the contest
Have an adequate number of references to “zompire dracularius”

While it seems a little “Black Hat SEO”/ dirty to me, I will ignore that feeling for a while for the purposes of the experiment. Results to come!

Thoughts on RDFa

Jay — Tue, 22 Sep 2009 14:32:36 +0000

Over the past couple of months I’ve been thinking a lot about semantic web — specifically how it fits in with the company’s overall future web development strategy. This has lead me to tinkering with RDFa markup, re-engineering current solutions with more forward thinking, semantic approaches. I have been a big proponent of microformats as a lightweight semantic markup tool (and I still think they have merit), but since have been intrigued and impressed with the power of RDFa. As with all new concepts, RDFa isn’t a “silver bullet” right out of the gate. Sitting down and actually coding the stuff into real-world examples has brought to light some potential issues that may be encountered by developers introducing RDFa to their pages.

Ontology Explosion?

Like RDF/XML, RDFa markup depends on identifying and utilizing specific ontologies in your HTML document. One could create a custom ontology specifically for a single use case. This could result in hundreds or even thousands of custom ontologies for the same concept or object. My fear is that that without proper oversight, the overabundance of ontologies will lead to a decrease in the effectiveness of RDFa, and clutter the semantic web with non-reusable ontologies. Since RDFa is recognized by the W3C, my hope is this group can provide some leadership and governance — possibly working to establish more officially recognized ontologies for use (and reuse!) on a wide scale.

Document Size

Maybe I’m just being old fashioned here, but are people still concerned about HTML document size and performance? I know my company is. In most of my examples, I saw an increase in the amount of HTML markup needed to fully code the page, usually between 5-20%, depending on the complexity of the solution. Efforts will need to be made by developers to streamline their code in order to avoid performance issues due to “heavy” HTML.

Object Order

For some ontologies, object order matters — that is, element y is in the domain of x, and should be nested under the parent. If your web page has a specific visual look and feel, will that match the object order needed to be valid RDFa? While flexible front-end development techniques using CSS will handle most of these instances, I foresee a certain amount of give and take between design/ information architecture staff and developers to achieve a balance of human usability while maintaining the data structure of the document.

Overall, I am convinced that RDFa is the right technology to fuel the semantic web, providing human usability and machine readability, even with the issues described above. In most scenarios, the benefits of delivering rich data directly to the front-end outweigh the effort to implement it. As adoption increases, new techniques will be invented that should alleviate most problems. After all, we developers are a smart bunch

Best Buy Local Store Sites Go Semantic With Good Relations Ontology

Jay — Fri, 05 Jun 2009 20:11:55 +0000

The experimentation continues on our Best Buy Local Stores platform. For the past year or so, I’ve been interested in going beyond the standard web experience and into the world of semantic web. I am out to create and find examples of how we annotate good store data beyond the confines of the typical web site, and what commerce sites will look like in a new semantic web. After some research, the GoodRelations Ontology seemed like an appropriate solution to provide better data around our stores and offerings.

The current solution involves publishing offering, payment methods, delivery methods, store details and store hour data in RDF/XML using GoodRelations for all 1000+ Best Buy stores in the US. Examples may be found on all Best Buy Local store pages. A couple of highlights:

A special thanks to Martin Hepp for his great work and assistance in this venture.

Hybrid Microformat/RDFa Example of the Day: Marking up Brick and Mortar Stores

Jay — Tue, 19 May 2009 17:41:26 +0000

As part of a recent local store web site project, we’ve been experimenting with how to represent physical store locations using microformats and RDFa in a hybrid approach, giving the parser/page scraper/app the ability to choose it’s own format to parse while keeping it visually simple for the end user. This example (live on 1000+ store pages) uses hCard and geo microformats along with FOAF and GEO RDFa specfications. There are some interesting observations I have noted from iterating on this a couple of times:

Does a hybrid approach make sense? Could this be applied to other microformat/RDFa instances?
I think it would be beneficial to come up with an approach for representing store hours in the data. To my knowledge there is no microformat to handle this. I did stumble on the GoodRelations ontology, and could apply this as an RDFa. Looks like GoodRelations also appears in Yahoo! SearchMonkey’s documentation.

The example. First things first, add RDFa DOCTYPE declaration and appropriate namespaces for validity (dublin core dc: appears further in the (X)HTML in the posts, does not appear in this example).

The core of the markup:


	
		Best Buy - Richfield
		
		
			
				1000 West 78th St
				Richfield, MN  55423
                        
			Phone: 612-861-3917
			GEO: 44.863312, -93.292557
		        Maps & Directions | Weekly Ad
		        Store Hours
			
				Mon: 10-9;
				Tue: 10-9;
				Wed: 10-9;
				Thurs: 10-9;
				Fri: 10-9;
				Sat: 10-9;
				Sun: 11-7

Download the src

hProduct Recipe of the Day: Hanging Pants Rack

Jay — Mon, 18 May 2009 19:24:23 +0000

Taken from Lilian Vernon (lillianvernon.com). Judging from the state of my trousers today, I could use one too…


	
		
			Home
			Store & Organize
			Closet & Drawers
		
		
			

			
		
		
			Deluxe Hanging Pants Rack
			SKU:
				046534
			
			
				Holds 8 pairs of slacks neatly with shelf for sweaters, shirts and more! 16" wide with non-slip plastic sleeves that prevent sliding. Silver finish. Easy assembly. 
				SAVE
$7
				Was $14.98
				Now $7.49
				Save $7.49
				
					Quantity 1

hproduct example src

hProduct Example of the Day: Gordon Ramsay

Jay — Thu, 14 May 2009 21:02:57 +0000

Today’s example of the day is visually presented like this:


	
		
			Magers and Quinn
			Books
			Cooking
			Quick and Easy Cooking
			Gordon Ramsay's Fast Food
		
		
			
			New: $27.99
			Pub price: $35.00
			Hardcover
			Out of stock
		
		
			Gordon Ramsay's Fast Food Recipes from the F Word
			By Ramsay, Gordon
			
				ISBN:
				1554700647
			
			
				Contributors:
				Sargeant, Mark (Contributor); Quah, Emily (Contributor); Mead, Jill (Photographer)
				Publisher:
				Amer Youth Hostels
				Published:
				2008
				Pages:
				255
				Weight:
				2.70lbs.
				Height:
				10.25"
				Width:
				8.00"
				Depth:
				1.50"
				Language:
				English  
			
			Publishers Comments
			A celebrity host of Hell's Kitchen features more than one hundred accessible recipes that are organized in accordance with everyday needs and special occasions, in a volume that places an emphasis on fast preparation and features complementary tips on stocking a pantry.

Download example markup (HTML)