Saturday, November 11, 2017

Intro to Natural Language Processing with LUIS

Here's the slides for the presentation I'm doing 11/16/2017 at the Granite State Windows Platform Developers (@WPDevNH) meeting in Salem, NH (at the Microsoft Store)

The group is primarily about Windows 10 app development (implying Universal Windows Platform, UWP).  That said, the group's been begging for sessions on AI and related services for some time.

Since I've been helping a client navigate LUIS lately, I figured an into to the LUIS service would be a nice way to break into this very useful service.

I reserve the right to tweak these slides up until I present them on Thursday, November 16th, 2017.


Please Join Us! 
RSVP HERE:

https://www.meetup.com/Granite-State-NH-WPDev/events/243099117/

UWP Equivalent for HttpUtility.ParseQueryString

Getting ready for my LUIS presentation at the Granite State Windows 10 Platform Devs Users Group (@WPDevNH), it made sense to demo LUIS using UWP rather than .NET classic.  (Join us, 11/16 at the Microsoft Store in Salem, NH...  https://www.meetup.com/Granite-State-NH-WPDev/events/243099117/ )

For a demo related to LUIS querying, I needed an alternative to System.Web.HttpUtility.ParseQueryString.  (based on this demo:  https://docs.microsoft.com/en-us/azure/cognitive-services/LUIS/luis-get-started-cs-get-intent )

I did a simple decorator of a Dictionary, adding a constructor to parse using WwwFormUrlDecoder, and overriding the ToString() to put it back together...

I whipped one up relatively quickly, but decided this would be a decent quick post.  Here's my alt code:

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Text;
using Windows.Foundation;

namespace LUIS_Examples
{
    public class ParseQueryString : IDictionary<string, string>
    {
        private IDictionary<string, string> _internalDictionary = new Dictionary<string, string>();
        public ParseQueryString(string queryString) :
            base()
        {
            var decoder = new WwwFormUrlDecoder(queryString);

            foreach (var item in decoder)
            {
                _internalDictionary.Add(item.Name, item.Value);
            }
        }

        public override string ToString()
        {
            var sb = new StringBuilder();
            foreach (var aPair in _internalDictionary)
            {
                sb.AppendFormat("{0}={1}", WebUtility.UrlEncode(aPair.Key), WebUtility.UrlEncode(aPair.Value));

            }
            return sb.ToString();
        }

        public string this[string key] { get => _internalDictionary[key]; set { _internalDictionary[key] = value; } }

        public ICollection<string> Keys => _internalDictionary.Keys;

        public ICollection<string> Values => _internalDictionary.Values;

        public int Count => _internalDictionary.Count;

        public bool IsReadOnly => _internalDictionary.IsReadOnly;

        public void Add(string key, string value)
        {
            _internalDictionary.Add(key, value);
        }

        public void Add(KeyValuePair<string, string> item)
        {
            _internalDictionary.Add(item);
        }

        public void Clear()
        {
            _internalDictionary.Clear();
        }

        public bool Contains(KeyValuePair<string, string> item)
        {
            return _internalDictionary.Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return _internalDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
        {
            _internalDictionary.CopyTo(array, arrayIndex);
        }

        public IEnumeratorstring, string>> GetEnumerator()
        {
            return _internalDictionary.GetEnumerator();
        }

        public bool Remove(string key)
        {
            return _internalDictionary.Remove(key);
        }

        public bool Remove(KeyValuePair<string, string> item)
        {
            return _internalDictionary.Remove(item);
        }

        public bool TryGetValue(string key, out string value)
        {
            return _internalDictionary.TryGetValue(key, out value);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_internalDictionary).GetEnumerator();
        }
    }
}