[MUSIC PLAYING]
ALICIA WILLIAMS: All right.
Hello, everyone.
Thanks for coming today.
I hope you had a
really good day one.
I've been waiting all day to
talk about analyzing text data.
But first I want to
introduce myself.
My name is Alicia, and I work
on the GCP and G Suite developer
relations teams.
And I'm looking mostly
at what data analysts do
and what solutions they need.
So I hang out a lot
in Spreadsheets.
But I'm starting to learn
more SQL and JavaScript
to kind of open up new
possibilities for what
I'm building.
There's a few products
down here that I've
been focusing on in the G,
like, the G world, Google.
It's kind of a quiz
for me, actually,
because these things
are hard to remember.
But I work a lot with Sheets,
Apps Script, Data Studio,
BigQuery, the machine
learning APIs, and GCP.
And also, Dataprep, and really,
anything and everything, even
outside of Google.
So I'm talking about
a few of these today.
So I work at Google.
It's a company that's
very data driven.
So whether I have interacted
with a service or a team
at work, or I've gone in an
off site with my teammates
or taken a training,
pretty much 95% of the time
I'm going to get some sort
of feedback survey asking
for my experience in that.
And it's not actually
limited to my work life.
I'm getting surveys
all over the place.
So when I travel,
I'm getting surveys.
When I'm shopping,
I'm getting surveys.
That doesn't happen too much.
When I'm evaluated
being, like, when
I'm interacting with
customer service
and they're asking me how
my interactions were--
this is just a few.
I went through my email
and it was insane how many
surveys I've gotten recently.
So why am I getting so many
and why are all of you?
Well, collecting and
implementing user feedback
is really one of the best
ways to improve your product.
So we all look at
analytics, and that
may be able to show
you what is happening,
but feedback really helps
us understand the why.
So if you go into
your analytics and you
see that people are using
one feature twice as
often as another, or people
are dropping off in the sign
up flow, or if people
stop using your product
or are using it less frequently,
by looking at the customer
feedback alongside
those analytics data,
you can get a much clearer
picture of what's going on.
And you can also start to see
both problems that need fixing,
but opportunities that
may be able to provide
more value for you and the
people using your products.
So you'll see in all
of these examples
that I showed you earlier, I
kind of highlighted in yellow,
they each have the opportunity
to provide open-ended feedback.
And so why are they
providing the opportunity?
Well, if you build
a survey that's
full of just rating scales
and multiple choice questions,
you're kind of
restricting the answers
to your own assumptions.
So by opening it
up, you're actually
going to really know what
your customers are thinking
and get things back that
completely surprise you.
So what I want to
talk about is how
we can collect,
analyze, and visualize
this open-ended feedback.
So there's probably a
lot of different ways.
I'm going to show
you one possible way
that I put together.
And I do work at Google.
And this is Next.
So definitely going
to come into play
some of these Google products.
But I want to tell it
through kind of a scenario.
And the scenario
is planning a trip.
So probably a lot of
you have planned a trip.
You go out to these websites
and you read feedback
on either hotels or
vacation rentals.
And the reviewers provide
really diverse feedback.
It can be about the
location, about things
they did in the area,
cleanliness in the actual hotel
room or in the vacation
rental, interactions
with the staff or
the facilities.
So I'm just going to--
I thought that was a really good
example of open-ended feedback
with diverse content.
So I'm going to walk you through
an example using an Airbnb
property actually
not in the Pyrenees,
in Boston, in the United States.
There's actually two
properties I analyzed.
I found the data
set on Kaggle, which
is data science platform
you might have heard about.
They have a ton
of open data sets,
and it's a great way
to kind of practice
playing with these tools.
So you'll see the
data as we go along--
what it looks like.
So let's start by talking about
how to collect that feedback.
I'm actually not going to
touch on survey design today.
I hope you didn't come
for a social sciences talk
because I'd actually love to
learn more about that too.
There's a lot of
complexities there.
There's things like proper
branching, and length
of survey, and who
you collect from,
and the primacy
and recency effect.
But I will talk about
the tools you can use
and the tools I'm going
to use in this demo.
So our architectural
diagram for this demo
starts here with Google Forms.
Don't worry.
There's going to be some more
things filling the space,
but not too much.
Just the right amount.
Google Forms really allows
you to create surveys
right in your browser.
Probably most of
you have used it.
It's very collaborative.
People without a Google
account can even edit and view
and respond to surveys.
There's actually
some analysis tools
built into the Google Form.
So you can get some immediate
analysis done for you.
There's also templates.
So I was looking
through the template.
There's even a template
for customer feedback.
So if you're a startup
and you're just
trying to get started with
collecting customer feedback,
there's a template for you.
People responding to the form
can actually upload files,
so they get could upload
images or documents
that you asked them for.
And there's other features, like
shuffling the multiple choice
responses, which help handle
the primacy and recency effect
that I mentioned earlier.
You can create prefilled URLs.
So like, I could
send this form out
to somebody that stayed
in a specific property
with that property prefilled
in the property ID.
And it's free, so
that doesn't hurt.
But on the right
is a simple form
that I created today just
to collect the feedback.
Now, I am going to be
running Airbnb feedback
through this form.
But you know, it's
a good example.
So now, where does all that
open-ended feedback go?
We've got the
external Google Form.
And when you set
up a Google Form,
you can choose two places
for it to store the data.
So it can either--
responses can be stored
inside the Google Form
or backed by a Google Sheet.
So I'm choosing to back
mine with the Google
Sheet for a few reasons.
First, because the Sheet can
be a playground for doing
a lot of analysis ad hoc.
But also, the Sheet will connect
to my data visualization tool
really well.
So I wanted to have
it ready to go.
So what does the data look like?
You're seeing kind of the
spreadsheet form of the Airbnb
data here.
So I have the timestamp of
when the form was submitted
and also the reviewer's
name, the property ID,
the first night
they stayed there,
and their open-ended comments.
So now that we have
the form collecting
the data and the
structure in place
for soliciting and
collecting that feedback,
I can kind of get to the true
headliner for this talk, which
is the analyzing.
So here we are back at this
sheet, full of responses,
and there's a lot
of text in there.
So I don't want you to panic.
I don't want you
to read all of it.
But this is kind of what we're
here to solve this afternoon.
You may even have
some spreadsheets
in your Google Drive right
now that are in this state.
So there's a couple ways we
can start to tackle that.
The first one, once you've
probably done before,
and it's not a bad
way, is manually
reviewing all of
those responses.
Well, this is pretty
energy intense.
It actually takes a
lot of energy to read.
And even at smaller
volumes, this data
set that I showed you on
the previous slide that
showed about 15
reviews out of the 716,
and that was text
clips, so those reviews
can get quite lengthy.
The text data is also
highly unstructured.
So there's grammar and
syntax rules to think about.
It can come in a number
of different languages.
So my data set actually
had 10 different languages
represented.
It is not really scalable.
Imagine we're going to
manually review this data.
And we're going to
start by looking
at maybe some specifics
about the property location
and the property cleanliness.
We can start reviewing
those and noting
when people mention
that, but what if we want
to add more entities to review?
So we also want to review how
the wireless internet worked
or additional properties.
Well, it starts to be very
labor intensive and not very
scalable.
We could then try to start
reviewing multiple properties.
Maybe I went to
review 10 properties.
So it just doesn't
scale, especially
when you are doing
this manually.
And finally-- oh,
this is my panic mode.
But finally, before I do
that, I want to just talk
a little bit about if you were
to find enough humans to do all
of this review, you would find
that the analysis was still
pretty inconsistent.
Because we humans
are very different,
and we interpret language
very differently.
So next, I want to think
about turning on the brakes.
So we've just kind
of had a panic moment
about reviewing all
of this text manually.
So what if we just changed
the way we collect the data?
So instead of giving
them that beautiful box
for free-form text, we just
imagine all of the ways
that they might want to
review or what we care about.
Well, like I said before,
this will inevitably
miss some really
great opportunities
that you can take based
on kind of those surprises
I talked about.
And in my case, I
don't work at Airbnb,
and I can't change the way
they collect their data.
So if you don't have control
over the data collection
process, you can't change
the data collection design.
So what we're going to try today
is leveraging machine learning.
And the best part about
this is it doesn't require
any machine learning expertise.
So to make that possible, we
have something called the Cloud
Natural Language.
So, Cloud Natural
Language is an API
for analyzing text using a
pretrained machine learning
model.
It has several features.
So, first, it can
extract entities
from text like proper
nouns or objects.
It can also detect sentiment,
so whether it's a positive block
of text or negative.
It can return linguistic
details by analyzing
the syntax of the text.
And it can also classify
text into categories.
So you can pass it
a block of text.
It will categorize it
into one of 700 categories
and let you know.
This might be good for something
like classifying newspaper
articles.
It can do that very well.
I'm going to
specifically use a method
that both extracts the
entities and detects sentiment.
So to get a sense of how Cloud
Natural Language can analyze
your data, I want to move to my
laptop real quick and show you.
Can we change to the demo?
Oh, it's up.
It's just not here.
All right.
So this is our product page
for Cloud Natural Language.
And what I'm going to do here,
there's a Try the API box,
which is really great.
You don't have to
set up any code.
I'm going to take one of
the examples of the reviews
from a property and show you
the visualization of what
the API would respond with.
So you can see here,
it returns a list
of entities from the text.
And for each entity--
for example, Sean-- there's a
sentiment score and a sentiment
magnitude.
The score ranges
from negative one
at very negative to positive one
for a very positive sentiment.
And magnitude ranges
from zero to infinity.
And it's really just the
strength of the sentiment,
regardless of being
positive or negative.
So, back to the slides.
So we have Cloud
Natural Language,
but how do I connect Cloud
Natural Language with Sheets?
So the answer here
is Apps Script.
Show of hands, how many of
you know about Apps Script
or have used Apps Script?
Awesome.
So you're going to be
ready to go with this.
So Apps Script is a
scripting language.
It's based on JavaScript.
And it has enhancements
that give you
the ability to automate
things across Google products.
What's great is I'm going to
use this to connect to Cloud
Natural Language, but
I'm going to use it
also for a lot of the
preprocessing in my spreadsheet
that I'm going to
do with the data.
The code editor's
right in your browser.
It runs on Google servers, so
there's nothing to provision.
And here's just a quick example
of a short snippet of code
to show you the power.
So this function,
sendMap, takes an address
that's in a cell in
a Google spreadsheet,
it renders a static
map, and it sends it
to an email address specified.
So this is using kind
of the enhancements
for Maps, Sheets, and Gmail to
send, in five lines of code,
a map to some email address.
And there's several services
beyond Maps and Gmail,
like Slides decks and more,
so you can do things really
quickly.
So, just to recap, we have
a form collecting the data.
It's backed by a Google Sheet.
And we have Cloud
Natural Language
ready to help analyze
the data and Apps Script
to help manage
that communication.
So I want to switch
back over to my demo
and show you kind of what
that looks like in action.
So here is the--
so I showed you a
screenshot of the form,
but I wanted to show you what
it looks like on the web.
It's a fairly utilitarian
form, because I'm not actually
publishing it for this purpose.
But it includes a dropdown
for the property ID,
first night of stay, and then
a short and long-answer box
for the reviewer's
name and comments.
On the form back
end, you can see kind
of what I mentioned earlier.
I think I can show you where you
can shuffle the order option.
This helps manage kind of any
of these primacy or recency
effect.
And over in the
Responses tab, you
can see the analysis
products I mentioned.
So it automatically shows
you some charts and graphs
based on the data that
you're getting back.
So in this case, we
got more responses back
for this blue property, 66288.
So that's Sean's property,
for future reference.
Now, let's look at
the Sheet that's
collecting the responses.
So here, in the
Form Responses tab,
this is where all of the
data will automatically
go when people answer the form.
Now, this tab, really, you can
add anything you want to it,
but it's designed to house
the data for the form.
So if you add a new question
to the form, which you can,
it will create a new
column to house that data.
I want to do some preprocessing.
I don't really want to get
in the way of the ability
to change the form.
So what I did is I created
another tab called Review Data.
Now, Review Data, you see it
has the same first five columns.
So this includes all
the data from the form.
But I also have three new
columns, so language detected,
comments English,
and entity sentiment.
So, in the language
detected column,
I have a formula which
returns the language
code for the comments text.
So it uses the function
called detectLanguage.
Not sure how big that is.
Secondly, in the
English comments--
I'm using Google
Translate to translate
any non-English
comments into English.
So, funny story.
When I first built
this spreadsheet
and I was doing this,
I actually used--
we have a Cloud Translation API
that can detect the language
and make the translation.
And it's only when I started
searching around, trying
to figure out how to use
this API and how to do this,
that I realized that Google
Sheets has built-in functions.
So that was actually
a great win.
The entity sentiment column is
actually being used as a flag
later on for when I process it
against Cloud Natural Language.
So I did process
a lot of the data
already, so it
shows as complete,
but I'm not really doing
any data processing there.
So to show--
I could copy all of the--
I could decide every
week, say, to go and look
for new responses, copy
them over to this tab,
and then paste
down the formulas.
But I can do this pretty
easily with Apps Script.
So I'm going to access Apps
Script editor through the Tools
menu, and it'll bring up a new--
make that a little bit bigger.
And I want to show
you the preprocessing
script that I wrote.
So this script
does three things.
What it does first is it
copies the form responses
into the review data sheet
for me, so those first five
columns.
It pastes in the formula
for detecting the language,
and it also pastes in the
formula for translating
comments to English.
And you'll notice
a couple things.
I'm using [? RON/CON ?]
notation because it
makes it really simple
to create formulas
with relative cell references.
And I also wanted to point
out that this function's going
to be triggered every time
the form is completed.
So when the form's
completed, there's
actually an event object that's
part of that event happening,
which I'm denoting here as e.
But it actually comes with an
entire response that includes
the values from that form.
So in fact, the script doesn't
copying from the Form Responses
tab to the Review Data tab.
It's actually taking data from
the actual event of someone
filling out the form and
copying that data into our tab.
So now that I've
set up the scripts,
how am I going to run it for
each new form submission?
Well, that's pretty easy.
I have a triggers
menu here that I've
set up a trigger for my
onFormSubmit function
to run from the spreadsheet
every time the form is
submitted.
I have some notifications
here, in case.
I can have it email me if
it fails, which is great,
especially when I'm testing.
But it hasn't been failing, so
that's-- we'll see, demo gods.
Now we're ready for that.
So now that you've seen kind
of what I've put together,
I want to show you in action
what this preprocessing looks
like.
So, I've submitted most of
the reviews to this form.
I want to get to the
bottom of the data here.
OK, so I've submitted most.
So you see I have 706
reviews, but I saved 10
in my back pocket to run.
Now I'm going to have to--
there we go-- in
my back pocket so I
could run it and
show you in real time
these form responses coming in.
So I actually wrote a script
that will submit responses
to the form.
And so I will set that to go.
There'll be 10 come through,
a few seconds in between.
So I'm just going to show
you kind of what's happening.
So we'll start to see them come
in here in the form responses
sheet as they're
completed, hopefully.
Oh, they're coming
in down there.
But then, you'll
also see that they're
copying into my Review
Data tab, and the formulas
are being copied in, as well.
So this way, anytime
somebody fills out the form,
I don't have to do
anything manually.
It's going to automatically
do my data preprocessing.
All right.
So we do see over here, though,
that the entity sentiment
column is not completed.
And this is because I have
a separate function that's
going to call the
Natural Language API.
So I'm going to go back
into my code editor
to show you what
that looks like.
So, I first want
to show you where
I make the call to the API.
So this function-- I'm calling
it retrieveEntitySentiment--
takes in a line of text.
So this is going to be,
ultimately, my comments.
And it's going to
package it up with all
of these options required
by the Natural Language API.
It's then going to
use UrlFetchApp,
which will make the request
to the API endpoint.
So this is the endpoint
for my analyzing entities
with their sentiment, and
then I have an API key.
So once I call the API,
it'll return a response,
and that will be what I return
at the end of this function.
So the second function I have
is kind of the workhorse.
Don't be afraid by all
of the lines of text,
because this is mostly kind of
giving it the lay of the land.
Where am I working?
But where it really
starts to get interesting,
down here, is where I
am processing each row.
So after the housekeeping items,
I'm going to find any rows--
so I'm going to process through
each row, look for any of them
that have a comment
in English but do not
have the complete value in
their entity sentiment cell.
And then I'm going to take
the comment in English,
and I'm going to run the
retrieveEntitySentiment
function, which is
what I just showed you,
which will call the
Natural Language API.
Then, with the response that
we get back from the API,
I'm going to take
each of the entities
that it identifies in the
text and their sentiment
magnitude, sentiment
score, and I'm
going to paste them into
new rows on a new sheet.
And then, finally, I'm going to
paste complete into that column
so that if I ever run
the function again,
it will skip over it and
it won't double count it.
And then, there's one final
really tiny but mighty function
in this script, which is onOpen.
And this is what
creates the menu
that I've been using to run
the script from my sheet.
So you can see that I can create
a new menu called Demo Tools
with any menu item I want.
And it can be associated
with a different function
in Apps Script.
So this is really great
because maybe you're
working with a diverse team,
and people shouldn't have
to always go into the editor.
You can pick to run
markEntitySentiment
from inside of here.
But it's much easier to
go into a spreadsheet,
see that you want
to run the function,
and then run it directly
in the spreadsheet.
So I'm going to choose to
run it from the spreadsheet,
since I went to the
work of making the menu.
But I want to get, again,
here-- so we're set up here.
We're set up here.
So I have run a bit
of the data already.
But I'm going to go ahead
and run this function.
And you'll see that
the entity sentiment
column starts to get
marked as complete
as the API goes
through each row.
And I start down here.
Let's see if we can catch up.
So for each review,
there's going
to be multiple entities here.
So Donald, we have
quite a few entities
coming in from his review
with their sentiment score
and magnitude.
There's also salience,
which is like the importance
of that entity within
the block of text.
And there's also a
number of mentions,
because people might mention
the same entity multiple times
within the review.
So that's running.
You'll also notice
I'm having the script
copy in a couple extra items,
so the timestamp, the reviewer
name, the stay date,
the property ID.
These are things that
came through on the form.
And I essentially wanted
a way to join back
the entities with
the comment that they
came from so that I can
always find the full text
review for the entities.
Because I don't have kind
of a unique identifier.
Timestamp could be
non-unique, for sure.
I wanted to talk a
little bit, though--
I did just manually
trigger this by running
markEntitiesAndSentiment.
But just like the
other script, I
don't want to have
to constantly think
about coming in
and running this.
I actually wrote
it in such a way
that I could set up a trigger,
similar trigger, to run this.
And what I would
choose for this trigger
would be to run
markEntitySentiment
maybe every half hour.
So I could do a minutes
timer every 30 minutes.
It would probably depend on how
often my data was coming in,
how quickly.
But this is a way I could
just keep the spreadsheet up
to date over time without having
to go in and manually run it.
The way I'm choosing my
triggers-- so the reason
why I separated them out,
the different preprocessing
and sending to the
Natural Language API,
is that the preprocessing
script is actually quite simple,
and it runs really quickly.
And to me, it made
really sense--
since it was quick
start to finish--
to just run every time
the form is completed.
It's not calling any other API.
So on the
retrieveEntitySentiment,
that API call can take
a little bit of time
only because it
pulls back the data
and then it's writing new lines
to that entity sentiment data
spreadsheet for
every new entity.
So depending on the
length of the comment,
it could take 30 seconds
to write those lines back.
And I don't want to
worry about limitations
around concurrent executions.
So by writing it in a way
that loops through each row,
calls the API, returns and
writes all of the response data
into the spreadsheet,
I can be sure
that I'm not going to come
up against any sort of quota
or limit on
simultaneous executions.
So I think we can go back
to the slides for now.
So now we have-- well,
actually, I didn't show you,
but we have almost
10,000 rows of entities.
So from those 715 reviews, we
have 10,000 different entities
that were identified and talked
about with their sentiment
and magnitude.
So this is a really great
way to visualize the data.
The tool I'm getting use
for visualizing the data
is Data Studio.
And that's like the completion
of this wonderful slide.
I would imagine that some of you
are familiar with Data Studio.
But for those of you
who aren't, the basics
are that it's Google's BI
and dashboarding platform.
It's free, and it's
available today in beta.
So why did I choose Data Studio?
Well, first, its
ability to connect
to my data source,
which is Sheets,
is particularly one
reason why I chose it.
It also connects to other Google
data sources like BigQuery,
Cloud SQL, Cloud Storage.
It also can connect
to Google services
like Analytics and YouTube.
If you have on-premise data and
MySQL, you can connect to that.
If you have other
data sources that
are accessible through
public APIs or enterprise
data over a private
API, you can build
something called a
Community Connector
to connect to that data source.
And those are written
in Apps Scripts.
So it's actually great,
especially for someone like me.
It can be an extension
of your new-found
or existing Apps Script
skills without having
to learn something new.
Also, there's hundreds of
data connectors already built,
and once you build one, you
can put it in a marketplace.
So maybe you don't want to build
your own Community Connector,
but somebody else already has.
So for a lot of
popular data sources,
there are Community
Connectors out there.
Secondly, the ease
with which I can just
create a pretty good
visualization quickly.
There's templates.
These are a few examples of
templates from the gallery
that Data Studio has.
But it's just really easy
to get your first chart up
and running.
And finally, Data Studio--
this is actually not a finally.
This is probably
my biggest reason,
but it's just built for sharing.
So you can share a Data
Studio report with a link,
just like Google Drive.
You can share it
publicly, privately.
You can use Data Studio
like a presentation, which
is kind of how I'll use
it later in this talk.
And you can also
embed it into a web
page, which is really great.
Anybody can view it.
Users can interact with it.
It's an interactive infographic.
They can drill down, and they
don't need a Google account.
So I'm going to switch
over now to my demo again.
And I want to show you,
actually, over here.
So I want to show you
how to get started.
We have our
spreadsheet, and I want
to connect and kind of
see my first visualization
of the data.
So I'm starting a
new report, and I'm
going to create a new data
source where I connect--
whoops.
I'm not going to learn more,
as interesting as that is.
Connect to our spreadsheet.
So I'm going to start and look
at the entity sentiment data.
And we'll see how
all this connects.
But it is doing a lot for you.
It's pulling the schema.
It's pulling the data types.
You can actually
preview these and decide
if I want to change
the type of data.
You can also add a field,
which I'm going to do,
because I forgot to do one
little thing in my Apps
Script, which was to do just
a little bit of normalization
on that text data by
lowercasing all of the entity.
Because if it comes in--
if Wi-Fi is capitalized
and then not capitalized,
I still want to
see those together.
So I'm going to save that.
I've just created a new field.
Go back here.
And so here's my new field,
and that looks good to me,
so I'm going to add
it to the report.
All right, so here
we have a bunch
of charts we can pick from.
I'm going to start
with a scatter chart.
And I want to see for each
of the entities kind of the--
we'll do number of mentions
on the x-axis, so what's
mentioned the most, and then
for the sentiment score.
So average sentiment
score for those entities.
And we can start to see
these entities coming in.
I'm going to
visualize the labels
but make it so we can see a few.
And then I'm going to change the
y-axis to go from negative one
to one, since that's what the
sentiment score can be between.
So you start to see
that, really quickly, I
was able to connect to my
Sheet and start and add
a field, even, which
would have been
a whole new column
in Sheets, and then
be able to visualize the data.
So let's pop over--
it would have taken
me a little bit longer
to come up with what
I'm about to show you--
and show you what I did
preparing for this talk.
So I just wanted to kind of
give a high-level summary
of the data that was coming
in from my response form.
So here, I can see submissions
on a monthly basis.
I can see the language that
they were submitted in.
I can filter on specific
property IDs or on time slices.
On my second page,
I'm starting to look
at the entities and their
average sentiment scores.
So here's actually
the scatterplot
that I created earlier.
So you can start to see in
the top right-hand corner
is things that are mentioned
a lot and are liked a lot.
Things below zero are
looked upon less favorably.
And on the right-hand
side of this,
you can see kind
of entities that
are mentioned with the
highest average sentiment
score, like value and
location, and entities
mentioned with the lowest
average sentiment score.
And these are
interactive, so I can
scroll through and see
additional entities
or, again, filter.
I think this page really
shows the viewer what
made an impression upon the
folks staying in these two
properties.
And then, thirdly, if
I want to drill down
into this specific entity.
So, I've decided, in this
case, to pick Sean's property
and look at mentions
of the word bed.
So in this case, I
have a histogram.
I can see when
people mention a bed,
is it mentioned
mostly neutrally?
But also, there's some people
mentioning it very positively
and some mentioning
it very negatively.
And also, we could see,
over time, the change
in the average sentiment
score for that entity.
This might be
especially interesting
if improvements were
made to the property
to see how that impacted
the sentiment overall.
And finally, if you do want to
drill down into that text data,
it's really nice to
be able to look at it.
Now, to get this data
set, if you remember,
I had the entities in one
tab and the full review text
in another.
So what I used to
put this together
is by blending the data.
So you can actually--
I'll show you this
in Data Studio.
So you can blend data sources.
So here, I was able to take
my entity sentiment data
and join it with my review
data on these three join keys.
And that way, I could
add the English comments
and the original comments
to one table that
includes all of these items.
And that was actually
very, very easy to do.
All right.
I will discard changes.
All right.
So I've stuck with a fairly--
I'm going to go back
to the view here
so you don't have to see that.
I stuck with a fairly
generalized report
here on the data received
from the feedback form.
I wanted to show
everything we got back,
but there's different audiences
you'd probably tailor this to.
If I'm targeting
the rental hosts,
I could probably focus on
what they're doing well,
what they're not doing well.
Maybe the Wi-Fi is
really great, but people
are complaining about plumbing.
If I'm targeting maybe
just the product team,
you could get a lot
of great insight
about what renters
really care about,
how to coach hosts on what
might be kind of a diamond,
that people actually really
care about hairdryers.
I actually didn't find
that in this data set,
but there could be things
that are surprising.
And then you might
decide, I want
to start collecting targeted,
quantitative feedback on that
from renters after they
stay in the property.
So folks already do this with
asking specific scores for one
to five stars on
location or cleanliness
and that sort of thing.
Because that's what they find
is very important to people.
But there's not to say,
potentially, other categories
you would want to dive into.
So now my report's
ready to share.
Again, I can share it
with select people.
I can share it with everyone.
Viewers can drill down into
the data, just like I did.
And it's great, because
they're able to do that
without having access to
the underlying data source.
So here, for example, I stripped
out the name of the reviewer.
So it does kind of provide
a layer of separation
between what the viewer can see
and the original data source.
So let's go back to my slides.
All right.
So when I think about what
this demo kind of solved today,
it was really
making the analysis
more consistent and scalable.
We added a numeric structure
to all of that text data.
So that made the analysis
and visualizations possible.
And we also
maintained the ability
to collect the
free-form text feedback.
We didn't have to change
how we collected the data.
So I wanted to give you guys
some resources for getting
started.
If you haven't
learned Apps Script
or you're still
learning Apps Script,
I'd definitely recommend
going to our overview page.
I actually also, when I
started learning Apps Script,
I took a Codecademy
JavaScript class online,
which helped me immensely.
I don't have a programming
background, so I it helped me
a lot understand the
notation of JavaScript.
Also, try the API
and the product page.
It's so much easier than having
to write the call yourself,
especially if you're
getting started.
And it gives you a sense
of if the machine learning
model really helps you
understand your specific data.
There's actually other
machine learning APIs,
like the Cloud Vision API, which
takes an image and extracts
metadata from that image.
So you could do a cool--
something with
your images, if you
have a big list of image
URLs in a spreadsheet,
trying to decode
what's in there.
So again, you can use the Try
It page and see what it can do.
I have a blog post that
is a similar demo to this
that does go through
and include code
on how to run this yourself.
But if you want to do the exact
demo I did today, front to end,
with the forms through
the Data Studio,
I do have the demo code that
I'm running on my GitHub.
So that includes instructions on
how to recreate this yourself.
And there's also a codelab.
I don't know if any of you have
been to the codelabs garden,
but those tutorials are great.
Because they give you
everything you need,
and they take you
through step by step.
And there's a codelab that's
very similar to this that
shows you how to connect a
Google Doc to Cloud Natural
Language to analyze sentiment
within a Google document.
So I also recommend
doing that codelab.
And there's some great sessions.
So today is over, and some of
my favorite sessions were today.
So I wanted to bring these
up, in case you guys wanted
to watch them later on YouTube.
But they talk about things
like our ML products.
Things like machine
learning APIs and AutoML
are very accessible to
people without a development
background.
And then, I just wanted
to say thank you.
So thanks for coming.
Please follow me on
Twitter and Medium.
I do have links to a few--
I have some Medium posts
that talked a little bit
about deep dives into
particular challenges
I had when creating this demo
and how I got through them.
So those might be somewhat
interesting to you.
And I'd also like to
hear back from you.
If you create some cool solution
using G Suite and our ML
APIs or a new Apps
Script project,
I'd love to hear about it.
So definitely send
those tweets to me.
All right, thank you, everybody.
[APPLAUSE]
[MUSIC PLAYING]
