Agent Configuration

Last updated: April 14th, 2018

How does it work?

Osone is an API that easily allows any developer to add intelligence to their applications. Osone allows you to implement agents in the cloud that can help you in making decisions, data science, natural language communication, etc.

01

You can start immediately

Osone allows you to create agents that add intelligence to your applications.

Anyone with basic experience in creating web or mobile applications can easily understand Osone It is not necessary to be an AI expert or a data scientist to create Osone.xyz agents. All you need is some understanding of the domain of your problem.

Osone is a service that allows you to create agents that add intelligence to your applications.

Try Osone

02

Convert knowledge into code

Osone allows you to convert your domain knowledge into code in order to configure each agent according to the needs of your application.

Our technique analyzes your data, according to the configuration you specify, and allows you to perform different processing tasks.

Osone's processing tasks allow for answers that express ideas such as:

  • Prices are lower on weekends.
  • Middle-aged divorced men and employees in some administrative position can earn more than 50k a year with enough certainty.
  • ....

03

Connecting your applications

Once you have created and configured an agent, you can request tasks from your Web or mobile application code. It will send you answers that your application can use to change their interactions with the user.

Osone provides a RESTful API for its code. We have SDK for many web languages, including Python, PHP, Ruby and Node.js.

04

FREE TO TRY. No credit card is required

Osone is free to try. You get 10,000 free requests per month, so you can start making decisions in your code immediately and see for yourself how it improves your software and delights your users.

As you scale, Osone scales with you. We have several levels of accounts that allow you to make hundreds of thousands or millions of API calls per month, with the level of technical support you need.

Login to Begin

Get Started

What is an Osone Agent?

An agent of Osone is an intelligent virtual machine in the cloud, with certain configuration, optimized for a specific domain, to which an application or a human will make its queries.

Configuring the Agent

The configuration of an Osone agent is based on the definition of a Meaning Map (OMM)*, the link to the data that will be processed by the Agent & the Processing Tasks that will be assigned to it.

We have chosen EDN Format to define the configuration of the Osone Agent.

Code scheme to configure Osone Agent
{
    :entities {...}
    :interpretation {...}
    :data-sources {...}
    :data-link {...}
    :process {...}
 }

The above code shows a API call that contains the main parameters to configure the agent.

Parameter Purpose
:entities :entities is defined.
:interpretation :interpretation is defined.
:data-sources :data-sources is defined.
:data-link :data-link is defined.
:process :process is defined.

Osone Meaning Map (OMM)

The Representation of Knowledge is an important area of Artificial Intelligence.

Osone Meaning Map (OMM) is the ontology proposed by Osone that allows to represent the Real World through the relationship of entities and concepts according to the interpretation of each agent involved in the reality represented.

In a very simple and easy-to-understand way OMM allows you to create Meaning Maps that remain independent of the data until you are asked for some processing task to the system.

Ontology Beta Version

*In this version of Osone, the Meaning Map is made up of the entries :entities & :interpretation

:entities

The Entities are the atomic elements of OMM. They determine the nature of the data that the Agent will process, which are how the types of variables to which the data should later be associated.

Example code for an entry :entities
:entities       {
                  :age            {
                                   :title     "Age"
                                   :data-type :continuous
                                   :unit      "Years"
                                   }
                  :workclass      {
                                   :title     "Workclass"
                                   :data-type :discrete
                                   }
                  :fnlwgt         {
                                   :title     "Final Weight"
                                   :data-type :continuous
                                   }
                  :education      {
                                   :title     "Education"
                                   :data-type :discrete
                                   }
                  :education-num  {
                                   :title     "Grade"
                                   :data-type :continuous
                                   }
                  :marital-status {
                                   :title     "Marital Status"
                                   :data-type :discrete
                                   }
                  :occupation     {
                                   :title     "Occupation"
                                   :data-type :discrete
                                   }
                  :relationship   {
                                   :title     "Relationship"
                                   :data-type :discrete
                                   }
                  :race           {
                                   :title     "Race"
                                   :data-type :discrete
                                   }
                  :sex            {
                                   :title     "Sex"
                                   :data-type :discrete
                                   }
                  :capital-gain   {
                                   :title     "Capital Gain"
                                   :data-type :continuous
                                   }
                  :capital-loss   {
                                   :title     "Capital Loss"
                                   :data-type :continuous
                                   }
                  :hours-per-week {
                                   :title     "Hours per Week"
                                   :data-type :continuous
                                   :unit      "Hours"
                                   }
                  :native-country {
                                   :title     "Native Country"
                                   :data-type :discrete
                                   }
                  :annual-income  {
                                   :title     "Annual income"
                                   :data-type :discrete
                                   }
                  }

The previous code shows the example of an entry :entities. With entity we mean anything from which we can have measurements (data) for any type of processing, for example "age", "relationships of a person", "income", "temperature", etc.

To process the data Osone asks that they be associated with entities (:data-link). This allows in principle to grant a semantic to the data very useful for processing with Osone.

For each entity definition, the following parameters can be declared:

Parameter Purpose
:title Provides a title or name for the defined entity. It must provide a short but accurate description or its purpose. When being associated the ordinary variables of the data with entities, this value attributes semantic characteristics to him.
:abstract It is a brief, appropriate and comprehensive summary that objectively and accurately represents the meaning of the defined entity. (Opcional)
:data-type Determines the type of the data it represents. Main possible values:
  • :discrete refers to data of the type of string, nominal that are not continuous numbers;
  • :continuous refers to continuous numerical systems;
  • :date refers to values of dates;
  • :fuzzy refers values between zero and one that previously fusify.
:unit Unit of measurement. (Opcional)

:interpretation

Each interpretation in OMM defines a certain context. Each context can be associated with the point of view of users at a certain moment or it can be the result of other computations.

The interpretation is defined by the States. The states are the possible values that the entities defined in :entities can take. These give Osone semantic characteristics and favor dialogue and communication when considering the answers according to the contexts.

Example code for an entry :interpretation
:interpretation {
                  :age            {
                                   "Young" (Rtrapezoidal min mean)
                                   "Old"   (Ltrapezoidal mean max)
                                   }
                  :workclass      {"x" ?}

                  :fnlwgt         {
                                   "x" ?
                                   }
                  :education      {"x" ?}

                  :education-num  {
                                   "More time studying" (Ltrapezoidal min max)
                                   "Less time studying" (Rtrapezoidal min max)
                                   }
                  :marital-status {"x" ?}

                  :occupation     {"x" ?}

                  :relationship   {"x" ?}

                  :race           {"x" ?}

                  :sex                                    
                                  {
                                   "Is woman" (nominal {" Female" 0.9} 0.2)
                                   "Is man"   (nominal {" Male" 0.9} 0.2)
                                   }
                  :capital-gain   {
                                   "Won a lot" (Ltrapezoidal min max)
                                   }
                  :capital-loss   {
                                   "Lost a lot" (Ltrapezoidal min max)
                                   }
                  :hours-per-week {
                                   "Work more" (Ltrapezoidal min max)
                                   }
                  :native-country {"x" ?}

                  :annual-income  {
                                   "More than 50k"            	 (nominal {" >50K" 1} 0.1)
                                   "Less than or equal to 50k" (nominal {" <=50K" 1} 0.1)
                                   }
                  }

The above code shows the example of an :interpretation entry that contains the states of the any entities defined in :entities.

For each entity, you can define as many states as you deem necessary, or not define them; In any case Osone can also find ideal conditions for you for certain processing conditions that you indicate.

The states for each entity are defined by a semantic value and an associated function that determines it. This function aims to convert the associated data into values between zero and one, where zero means the negation of the state to happen and one means its affirmation.

This function is what initially converts the data into information. The data are, in essence, measurements of reality that begin to take meaning when they are interpreted.

Osone offer all the potentialities so that the data is processed as information from the beginning, depending on certain contexts, favoring, among other things, the creation of an ecosystem of truly personal applications, where the human is the true protagonist.

The functions are represented by the name of the function and the parameters of the function are followed.

The following are the possible functions that can be used:

Function Entity Type Parameters/Example Graph
nominal :discrete values-map, not-found-value

(nominal {"Mercado Libre" 1 "Amazon" 0.9 "Bestbuy" 0.9 "Wallmart" 0.8 ...} 0)
trapezoidal :continuous a, b, c, d

(trapezoidal 3 5 7 10)
Ltrapezoidal :continuous a, b

(Ltrapezoidal(3 7)
Rtrapezoidal :continuous a, b

(Rtrapezoidal(3 7)
triangular :continuous a, b c

(triangular (2 4 9)
gaussian :continuous center, deviation

(gaussian(6 1)
pseudo-exp :continuous center, deviation

(pseudo-exp(6 1)
sigmoid :continuous center, beta

(sigmoid(6 1)
-sigmoid :continuous center, beta

Dsigmoid :continuous a, b, c, d

(Dsigmoid(2 3 8 3)
Sform :continuous a, b

(Sform(3 8)
Zform :continuous a, b

(Zform(3 8)
fgamma :continuous a, b

(fgamma(1 0.3)

Linking data

In the entries :data-sources & :data-link the link to the data that the Agent will process is defined.

Osone reads the data that is shared for specific tasks without affecting the original structures of these.

Example code for an entry :data-sources
:data-sources   {

                  :bd-adult {:path "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
                             :type :csv
                             :range[min 100] }
                  }

The previous code shows the example of an entry :data-sources that tells the Agent where to find the data that this will process. In :data-sources you must define at least one data source and as many as necessary.

Sample Database & Proposed Problem

In these example codes we refer to public information about adults, published in the UC Irvine Machine Learning Repository.

Related problems are posed to determine if a person makes over 50k in a year.

For each Data Source, the following parameters can be declared:

Parameter Purpose
:path It is the route where Osone must find the database.
:key When more than one data source is defined this key indicates the field by which the relationship should be established. They must be unique keys. This version of Osone is limited to processing data sources related one by one.
:type Indicates to Osones the type of data (:excel, :csv, :sql, etc).
:delim It is the character that delimits the data. For example in the CSV files.

Process Tasks

The Osone Processing tasks are very easy to understand and implement. But that's not why they are simple; We have done the dirty work for you so that with simple instructions each agent can scrutinize the data in search of answers.

What makes Osone special?

Powerful algorithms, revised and improved every day by a valuable team of internationally renowned scientists and authors of innovative procedures implemented in Osone, are placed in the hands of any user so that they can easily incorporate them into their applications, without any need for knowledge in Statistics, Soft Computing, Data Science or Artificial Intelligence.

Example code for an entry :process
 
:process    {
	
    :discovery-task-1 {
        :discovery {
            :patterns {
                "Any Search" {
                    :include   [
                        :age-adult
                        :workclass-adult
                        :education-adult
                        :marital-adult
                        :ocupation-adult
                        :rel-adult
                        :race-adult
                        :sex-adult
                        :hours-adult
                        :native-adult]
                    :operators [AND OR EQV IMP NOT]
                    :depth     1
                    }}
                :expression (IMP "Any Search" {:income-adult "More than 50k"})
                :parameters {
                    :logic       :GMBC
                    :population  100
                    :iterations  10
                    :rules       1
                    :truth-value 1
                    }}}

        :evaluation-task-1 {
            :evaluation {
                :expression (AND {:education-adult "x"} {:income-adult "More than 50k"})
                }}
                  }

The previous code shows a scheme of how to declare the processing tasks in Osone, which are detailed below.

Discover Tasks

:discover allows you to discover any hidden relationship in the data, and obtains understandable answers for both machines and humans.

:discovery-task-1 shows example code of a processing task that asks Osone to discover expressions with the form
"Any Search IMP Annual income More than 50k".

Parameter Purpose
:patterns Patterns for the formation of expressions. You can define as many as you like. Expressions in Osone are structures of the type "tree" resulting from combining the variables by logical operators.
:include A List with the variables to include in the expression.
:operators Logical operators that will be used in the formation of the expression.
:depth The maximum depth with which the Osone algorithm will form tree-like structures for the formation of expressions.
:parameters Advanced parameters of the algorithm.
:expression It is a symbolic expression that represents what you want to discover. Based on this :discover will return the results.

You can find more information about the parameters of the processing tasks, the general algorithm of Osone, the interpretation of the logical operators and others in the advanced documentation of Osone.

Evaluation Tasks

:evaluation evaluates a certain expression in the dataset.

:evaluation-task-1 shows an example code of a processing task that asks Osone to evaluate the expression
"Education AND Native Country IMP Annual income More than 50k?".

Forecast Tasks

Given an ordered set of data :forecast is able to obtain rules that allow the prediction of unknown variables.

Example code for an entry :forecast

	{
    :forecast   {
        :known-vars [:open :close :dif]
        :order      :stock-exchange-date
        :target     [:dif-next]
        :depth      5
        :timelag    5
				}
	}						 
											

The previous code shows an example of the use of :forecast in the stock market prediction.
Given the known historical values "open", "close" and "dif" of any stock index, ordered according to the date, Osone is asked to obtain the rules that allow predicting the trend of the next closing, "dif-next".

Parameter Purpose
:known-vars The variables with which Osone will form the Forecast Rules.
:order Indicates the variable by which the data are ordered for the purposes of the forecast.
:target The objective variables of the forecast.
:depth The maximum depth with which the Osone algorithm will form tree structures for the formation of forecasting rules.
:timelag The times that the Osone algorithm can return backwards over the same variable in order to use it in the forecast rules.

Inference Tasks

Given a set of Condition Variables :inference: is able to obtain rules that allow inferring Variables of Desicion.

Example code for an entry :inference
{
    :inference  {
        :known-vars [
					:age-adult  
					:workclass-adult
					:fnlwgt-adult 
					:education-adult 
					:grade 
					:marital-adult
					:ocupation-adult
					:rel-adult 
					:race-adult 
					:sex-adult 
					:gain-adult
					:loss-adult 
					:hours-adult 
					:native-adult]			
        :target     [:income-adult]
        :depth      5
				}
	}

The previous code shows an example of how to ask Osone to solve the rules, given the variables known in this example, that allow us to infer whether the annual income of a given adult will be greater or less than 50k.

Parameter Purpose
:known-vars The variables with which Osone will form the Inference Rules.
:target The objective variables of the inference.
:depth The maximum depth with which the Osone algorithm will form tree structures for the formation of inference rules.

:algorithm

The general parameters for the Osone Processing Algorithm.

Example code for an entry :algorithm

	:algorithm {
		 :logic [:GMBC]
         :variants 50
         :iterations 4
         :rules 1
         :stop-condition 2
         :mutations 30
				}					 
											

The above code shows the example of the general parameters for the Osone algorithm.

Make calls to the API

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa.

Make calls to the API