I've set up an sdk environment running to use azure form recogniser that is currently using the pre-built document layout model as an example.
Is it possible to use this environment to train a new custom model? I can't find any documentation relating to how I might start. I can't use the form recogniser studio to train the model, as it won't allow me to access the correct subscription to do the work in.
Related
I have built a custom model for identifying customer specific entities in Watson Knowledge Studio. Can i leverage and reuse standard entities (e.g. Email) which are part of the standard model in the custom model without having to redefine them from scratch?
I had the same question and found the info below - more details are at: https://watson-tricks.blogspot.com/
Post titled - "Combining the annotation capabilities of both Watson Knowledge Studio and Watson Discovery Service"
"It is not feasible for users to build a complete WKS model that incorporates all of the normal language dictionaries as well as the specialized domain terminology. However, there is a trick which can be used to get WDS to use both the domain specific annotator from WKS and the generic language annotator from WDS.
Unfurtunately this trick is not possible with the normal WDS UI, but it requires the use of the REST API"
I couldn't find enrichment for NLU. However i simply called the Analyze request two times, once with a custom model for Entities and second time without it. Got two JSON's and will combine the two to get a final list of entities. Not cost effective though as the number of requests will increase
I am completely a newbie in Bonita and BPM in general, in my introductory video lessons, I have so far learned about data models, the UI among others. So what I wanted is to know the components, I don't know what they are called but I call them components, I mean contracts, data models, and the likes, what are others that are involved in BPM because I don't even know how to google that.
Any help will be highly appreciated, even a link will be very useful.
Bonita BPM includes three main components:
Studio: the tool to design your processes. Also include an embedded test environment.
UI Designer: a web tool included in the Studio that let you create end user web interfaces.
Portal: the end user web interface to interact with processes. Also used by the administrator to deploy process, configure...
Engine: the technical component responsible for process execution.
You also have several important concepts in Bonita BPM:
Process definition: this is the model of the process with tasks, gateway... You create it using Bonita BPM Studio.
Business Data Model: this is a model of your data that you can create using Bonita BPM Studio. This model will generate a set of Java classes that represents your business data and also associated code to save and retrieve all those data from a database. Data define in this model are shared by all process definitions.
In a process definition you can declare business variables. They are actually reference to the business data store in the database. You can instantiate them using default value of your business variables. You can update them using operations on tasks.
Contract define the data expected by the Engine in order to instantiate a process or execute a task. End user will usually submit a form to start a process or execute a task. Contract define which data is expected from the form submission.
Forms are created using UI Designer. A form is actually a set of widget bind to form variables. The forms variables can be initialized using REST API call or by user input in the widget. REST API call can be done for example to get business variables values or access external system such as a database. Submit button is also associated to a form variable. This form variable must contains all information required by the contract.
Connectors are part of the process definition and let you interact with third party system when the process is executed. For example it can call a web service to decide if a specific path need to be taken or not.
I would recommend to checkout getting started tutorial in the documentation. You can also watch BPM Camp videos.
It seems this can be hacked into Django, but I'd rather prefer a framework that has better support for end user defined models.
Basically, I want the users of my app/website to be able to do at the runtime of the application what I do at compile time when writing the Model code: specify models that generate/modify a database schema. Obviously I cannot let the users of the webApp modify the code in models.py, so there has to be another way. Concurrency shouldn't be an issue, since each user-defined model would belong to only one user.
I don't mind using any programming language (Python, Haskell, JavaScript etc.) or any specific database SQL, NoSQL, whatever. Rails/Django freed me from writing a lot of repetitive code, now I simply want that functionality of modifying the model also at runtime (and preferably the corresponding views and controllers). If there is a good framework that rids me of writing all that code then I'll use it.
If there's no framework supporting it natively, does someone know a framework that at least makes it easy?
Portofino version 3 (http://www.manydesigns.com/en/portofino/portofino3) allows a modeler user to create data models interactively using a web interface called the "upstairs level". The system automatically generates a user interface (CRUD, charts, workflows) based on the model definition, without recompiling and basically in real-time with model changes.
You can check the reference manual to see what kind of models are supported:
http://www.manydesigns.com/en/portofino/portofino3/3_1_x/reference-manual
Currently Portofino 3 is an end-of-life version. The newer version 4 (http://www.manydesigns.com/en/portofino) is a significant re-write that currently does not support online editing of the data model as version 3 did, but keeps the same principle of making the application editable (through admin/configuration pages) and customizable (using Groovy) online without recompiling or restarting the server.
For data-model changes and db refactoring, Portofino 4 relies on Liquibase:
http://www.liquibase.org/
Here is my problem for using mvc2, I cant find a silver bullet fix for this.
I have a standard mvc app which has following views, controllers and Models
View
WorkOrders
Estimates
Model
WorkOrder
Estimate
Controller
WorkOrderController
EstimateController
I recently got a client who wants this app with little customization. I am still adding new modules to this app so I dont want to clone my app and customize because then I have to maintain two code bases. Upgrading any modules in base app as well as app that I cloned.
So here is how my Client App will look like
View
ClientWorkOrders
Estimates
Model
WorkOrder
Estimate
Controller
ClientWorkOrderController
EstimateController
Now If I want to add invoice I have to add it at both apps. Any easier way to handle this in microsoft mvc.
Without knowing much about the application -- you could turn to the provider model (depending how much additional functionality they need) or you could implement a plugin framework. Both options could be a huge architecture change.
I've never used it, but the MEF framework was specifically designed for creating plugin architectures.
I'm using Ruby on Rails for an internal site. Different users of the site have access to a wide variety of data and highly disparate perspectives of the data. Within those different classes of users, there needs to be levels of access. Within the levels of access I need to be able to add features from other classes of users.
In the released "Version 1.0" of the intranet site I have implemented the general classes of users. I am now needed to implement much finer-grained control of a users access.
The question is how?
What is the generally accepted practice for coding up user preferences (display the map (or not); access to this feature, but not this feature) without exploding the database schema and populating the view code with <% if feature_allowed %> tags everywhere.
Another totally different approach would be to use acts_as_authenticated and authorization plugins. The tables will be built by the plugins (ie users, roles and roles_users). From the doc:
The authorization plugin provides the following:
A simple way of checking authorization at either the class or instance method
level using #permit and #permit?
Authorization using roles for the entire application, a model class, or an
instance of a model (i.e., a particular object).
Some english-like dynamic methods that draw on the defined roles. You will be
able to use methods like "user.is_fan_of angelina" or "angelina.has_fans?",
where a 'fan' is only defined in the roles table.
Pick-and-choose a mixin for your desired level of database complexity. For
all the features, you will want to use "object roles table" (see below)
populating the view code with <% if
feature_allowed %> tags everywhere.
I don't think you want to do that. Assuming none of the alternatives suggested are practicable, at the very least you should consider shifting those checks into your controllers, where you can refactor them into a before_filter.
See section 11.3 in "Agile Web Development With Rails" (page 158 in my copy of the 2nd edition) where they do exactly that.