I am using Microsoft Cognitive service Face API for face detection. While Working I see we need to create person group and creating person group is mandatory for identifying person. I check about the "Person-Group" a lot but didn't get anything. Can you please help me out to know what's the actual use & significance of "Person-Group".
For face identification/verification, you scope the search to the set of Person objects. This set is called a PersonGroup. In computer vision terms, the PersonGroup is the image classifier unit, and is trained from the faces of the Person objects contained therein.
Related
I am trying to find where and how I could extract the data from our company to use in Power BI.
We are using AzureAD/Office365 (synced with Active Directory) to manage our users. The data is entered so that we can see the reporting structure in our various applications.
If it is unclear what I mean, you can see the link below
Creat Orgchart structure on Asuze AD
I was hoping someone knows how the data can be retrieved and had some examples of how to collect the data.
I have found meaningful examples to do the rest of the work (e.g. Parsing Organizational Hierarchy or Chart of Accounts in Power BI with Parent-child Functions in DAX) but I am stuck with figuring how to extract the data. Off-course I could maintain a separate chart, but it is likely that it would get off-sync and requires additional time to maintain (when employees onboard/off-board).
I have found one link explaining how to get data from Active Directory, but I believe that the information extracted in my case does not contain the data I seek.
Active Directory hierarchy - getting all users inside a group including child groups
I hope that someone implemented this previously and can share some code and or guidance with me. If I find a solution I'll make sure to post some code.
Based on the reference from So thread.
We can extract the data of Company Organization Chart (Upwards \ Downwards)
Up Hierarchy:
GET /me/manager
GET /users/{id | userPrincipalName}/manager
Also,
https://graph.microsoft.com/v1.0/me?$expand=manager($levels=max;$select=id,displayName)&$select=id,displayName&$count=true
Down Hierarchy:
GET /me/directReports
GET /users/{id | userPrincipalName}/directReports
Reference:
https://learn.microsoft.com/en-us/graph/api/user-list-manager?view=graph-rest-1.0&tabs=http
https://learn.microsoft.com/en-us/graph/api/user-list-directreports?view=graph-rest-1.0&tabs=http
Trying to create a set of entities & intents for things of the ilk "describe <something>" or "tell me about <something>" or "list instances of <something>". The <something>s are not known in advance. Consequently, I cannot exhaustively list the possible values for the entity.
My impression from (albeit very little) use and from the documentation is that the conversation API isn't good at this type of thing. Experience thus far says that it will recognize things that match the examples given for some entity, but I haven't seen that it can generalize to something like
describe #target
show me instances of #target
without knowing the set of values for #target.
What am I missing?
Based on your example, you can combine the Intents and Entities for your purpose.
It's a good practice, I think.
Like Daniel said, you can create one intent with examples for asking about something, like these examples within your #describeAbout:
Describe about
Can you please describe
Can you please explain about
List instances of
etc...
And create one entity like #typesDescribe, with yours values. Like this values:
Paper
Love
Fruits
After Watson training your examples, with your Dialog, create one flow with the condition
if #describeAbout AND #typesDescribe:Paper
Response:
#typesDescribe (Will show the value: Paper) is a thin material produced by pressing together moist fibres of cellulose pulp derived from wood, rags or grasses, and drying them into flexible sheets.
And, usually, if your confidence about Intent and Entity are small, you can add one more condition for your Intent with the confidence level that you want. Check.
Obs.: You can create one Intent alone, with condition #describeAbout, and the response will ask for your user "You can know what?", and create one flow with various #typesDescribe:value, for example.
Which services are you talking about? NLC is able to do this, and so is Conversation, by using wildcards. Either one of these can be trained to recognize intents with wildcard values in their training data. Just use an asterisk ( like this - "*" ) for the wildcard.
You don't have to train Conversation with every possible utterance, it learns from it's training data. So if you provided the service a series of utterances like "describe apples", "describe oranges", "describe fireflies", and "describe astrophysics", and then associated all of them with an intent of "#provide_description", then the Conversation service would indicte this intent for requests like "describe math".
Please also try to use real utterances for your training. I am not sure that your users will speak in two word sentences all of the time. Provide enough training data for each intent so the service is able to learn the various different ways people express the same intents.
I'm currently working on a project where the data graph is very confusing. For example if you want to find the region to which a contract will be applied, instead of just
having a FK for the region in the Contract table, you will only have a FK of the agency who is in charge of monitoring the contract, then from that table you will link to the
department of your company who is in charge of dealing with that agency, then from that department you will move toward the business unit ID, then from the Business Units table
you will eventually find a FK to the region you're interested in.
This is a real pain, because in addition to this, the business logic is implemented in the database and it is an industry which is quite complicate.
So when developing, we are dealing with two complexities : finding our data, and understanding the business logic.
Understanding the data graph actually requires to have a very good understanding of the domain. I know and I agree that every developer should understand the domain on which he is working,
but here it's a very a huge task. We are talking about a regulated industry, with a lot of specific rules.
And with the example I've given, you can see that even if you are working
on the Contract Creation module, you can't just say : well, I'll go ahead and study deeply the domain for that part, because when it comes to finding the region, you'll eventually need to know that you will find it at the other part of the data graph.
And it was really just an example, the real entities are much less intuitive than that.
I had an idea yesterday. Since in SQL Server we have access to the schema of all the database, I would like to write a script that would take 2 arguments :
-The Table StartPoint's Name
-And the Column name we are after.
And it would return a "graph" of all the paths that are possible to access it.
Is it an easy task to do, and how would you go about it ? (I am not an SQL Server expert)
It would be a fairly large task for me to write this out, but if you create a recursive CTE, using sys.foreign_keys and sys.foreign_key_columns, you could accomplish this. I think this post, Traverse through all foreign keys in database and generate a path , or this one, https://social.msdn.microsoft.com/Forums/sqlserver/en-US/66f379e1-32bc-44cb-bb48-93f42993ba23/is-there-a-way-to-determine-the-order-in-which-you-need-to-perform-deletes-when-there-using-a?forum=transactsql , is close to what I'm picturing, and then just applying a WHERE filter.
I'm trying to develop a simple app for my staff to log their time and expenses on a remote (access) db, and then sync that with QuickbooksPro. I have managed to get QBFC to work, my problem now is understanding the underlying database structure (field names etc) in Quickbooks - e.g. so I know which elements to add to queries etc.
I have found the following (EntityRef, CustomerRef) by trial and error, and by looking at a table pulled using QOBDC; however, there must be documentation of this somewhere - anyone know where?
TimeDataQry.IncludeRetElementList.Add("EntityRef")
TimeDataQry.IncludeRetElementList.Add("CustomerRef")
TimeDataQry.IncludeRetElementList.Add("TxnDate")
TimeDataQry.IncludeRetElementList.Add("BillableStatus")
TimeDataQry.IncludeRetElementList.Add("Duration")
TimeDataQry.IncludeRetElementList.Add("TimeModified")
to be honest, the actual QB data schema is horrible - huge and confusing. It's not worth trying to figure out how to interact directly with their API. That's one of the reasons people like QODBC created simpler ways to interact with it. Have you purchased QODBC?
I've created apps using QODBC and RSSBus, and I like RSSBus better. There are many reasons, but for starters, QODBC is actually a driver that uses DNS's, which can be confusing and have to be set up on each computer that you want to use this on whereas RSSBus does not have any of that. What QODBC and RSSBus do is wrap the QB db in a sort of sqlserver-like db, so any table structures you pull from the QODBC tool will most likely have no correlation to anything you could use through QBFC.
I prefer RSSBus now, but here are links to documentation for both:
RSSBus - http://www.rssbus.com/kb/help/RQR3-A/pg_imetracking.rst
QODBC - http://doc.qodbc.com/qodbc/Qodbc_20_us.html
Also, this SO question may help - QuickBooks QBFC explanation. Notice that he says there are 300+ pages of documentation for this. A little too much imo.
Use the QuickBooks OSR (it works best in Chrome):
https://developer-static.intuit.com/qbSDK-current/Common/newOSR/index.html
Choose the request/object type you're dealing with from the "Select Message" drop-down, and click on any of the nodes to view documentation on the node.
For example, what you posted above looks like you're looking at Time Tracking entries. Here's what you get from the OSR about EntityRef:
Entity
A QuickBooks "entity" is a customer, vendor, employee, or
person on the QuickBooks "other names" list. Special cases to note:
In a BillToPayQuery message, EntityRef refers to the vendor name.
In
JournalCreditLine and JournalDebitLine messages for A/R accounts,
EntityRef must refer to a customer, or else the transaction will not
be recorded. For A/P accounts the EntityRef must refer to a vendor, or
else the transaction will not be recorded.
In a TimeTracking message,
EntityRef cannot refer to a customer, only to an employee, vendor, or
person on the "other names" list whose time is being tracked.
Pretty simple, pretty detailed.
It's also worth noting that the QuickBooks APIs almost exactly mirror the QuickBooks GUI. For example, when creating an invoice in the QuickBooks GUI, you'll see fields like:
Customer
Date
Invoice #
Item
PO Number
And then if you look at InvoiceAdd in the API, you'll find these fields:
CustomerRef
TxnDate
RefNumber
ItemRef
PONumber
It shouldn't be terribly difficult to put two and two together and figure out that these fields match the fields presented in the GUI.
Here is the QODBC documentation on table schemas:
All Tables.
If you want specific US related table groupings like Customer and AR then check here:
Tables by Group
Graph databases store data as nodes, properties and relations. If I need to retrieve some specific data from an object based upon a query, then I would need to retrieve multiple objects (as the query might have a lot of results).
Consider this simple scenario in object oriented programming in graph-databases:
I have a (graph) database of users, where each user is stored as an object. I need to retrieve a list of users living in a specific place (the place property is stored in the user object). So, how would I do it? I mean unnecessary data will be retrieved every time I need to do something (in this case, the entire user object might need to be retrieved). Isn't functional programming better in graph databases?
This example is just a simple analogy of the above stated question that came to my mind. Don't take it as a benchmark. So, the question remains, How great is object oriented programming in graph-databases?
A graph database is more than just vertices and edges. In most graph databases, such as neo4j, in addition to vertices having an id and edges having a label they have a list of properties. Typically in java based graph databases these properties are limited to java primatives -- everything else needs to be serialized to a string (e.g. dates). This mapping to vertex/edge properties can either be done by hand using methods such as getProperty and setProperty or you can something like Frames, an object mapper that uses the TinkerPop stack.
Each node has attributes that can be mapped to object fields. You can do that manually, or you can use spring-data to do the mapping.
Most graph databases have at least one kind of index for vertices/edges. InfiniteGraph, for instance, supports B-Trees, Lucene (for text) and a distributed, scaleable index type. If you don't have an index on the field that you're trying to use as a filter you'd need to traverse the graph and apply predicates yourself at each step. Hopefully, that would reduce the number of nodes to be traversed.
Blockquote I need to retrieve a list of users living in a specific place (the place property is stored in the user object).
There is a better way. Separate location from user. Instead of having a location as a property, create a node for locations.
So you can have (u:User)-[:LIVES_IN]->(l:Location) type of relationship.
it becomes easier to retrieve a list of users living in a specific place with a simple query:
match(u:User)-[:LIVES_IN]->(l:Location) where l.name = 'New York'.
return u,l.
This will return all users living in New York without having to scan all the properties of each node. It's a faster approach.
Why not use an object-oriented graph database?
InfiniteGraph is a graph database built on top of Objectivity/DB which is an massively scalable, distributed object-oriented database.
InfiniteGraph allows you to define your vertices and edges using a standard object-oriented approach, including inheritance. You can also embed a defined data type as an attribute in another data type definition.
Because InfiniteGraph is object-oriented, it give you access to query capabilities on complex data structures that are not available in the popular graph databases. Consider the following diagram:
In this diagram I create a query that determines the inclusion of the edge based on an evaluation of the set of CallDetail nodes hanging off the Call edge. I might only include the edge in my results if there exists a CallDetail with a particular date or if the sum of the callDurations of all of the CallDetails that occurred between two dates is over from threshold. This is the real power of object-oriented database in solving graph problems: You can support a much more complex data model.
I'm not sure why people have comingled the terms graph database and property graph. A property graph is but one way to implement a graph database, and not particular efficient. InfiniteGraph is a schema-based database and the schema provides several distinct advantages, one of which object placement.
Disclaimer: I am the Director of Field Operation for Objectivity, Inc., maker of InfiniteGraph.