Examples of InstanceList

cc.mallet.types.InstanceList
A list of machine learning instances, typically used for training or testing of a machine learning algorithm.
All of the instances in the list will have been passed through the same {@link cc.mallet.pipe.Pipe}, and thus must also share the same data and target Alphabets. InstanceList keeps a reference to the pipe and the two alphabets.
The most common way of adding instances to an InstanceList is through the add(PipeInputIterator) method. PipeInputIterators are a way of mapping general data sources into instances suitable for processing through a pipe. As each {@link cc.mallet.types.Instance} is pulled from the PipeInputIterator, the InstanceListcopies the instance and runs the copy through its pipe (with resultant destructive modifications) before saving the modified instance on its list. This is the usual way in which instances are transformed by pipes.
InstanceList also contains methods for randomly generating lists of feature vectors; splitting lists into non-overlapping subsets (useful for test/train splits), and iterators for cross validation. @see Instance @see Pipe @author Andrew McCallum mccallum@cs.umass.edu
nexj.core.runtime.InstanceList
Interface for representing object instance lists, esp. association collections. Supports efficient membership checks and does not allow duplicate objects.
shared.InstanceList

Examples of cc.mallet.types.InstanceList


    if (printOption.value) {
      for (int i = 0; i < clusterings.size(); i++) {
        Clustering c = clusterings.get(i);
        for (int j = 0; j < c.getNumClusters(); j++) {
          InstanceList cluster = c.getCluster(j);
          for (int k = 0; k < cluster.size(); k++) {
            System.out.println("clustering " + i + " cluster " + j + " element " + k + " " + cluster.get(k).getData());
          }
          System.out.println();
        }
      }
    }

View Full Code Here

Examples of nexj.core.runtime.InstanceList

            }


            oid = getKey(query.getParentItem());
         }


         InstanceList instanceList;
         boolean bAdd = true;


         if (container == null)
         {
            instanceList = m_instanceList;
         }
         else
         {
            Object value = container.getOldValueDirect(assoc.getOrdinal());


            if (value == Undefined.VALUE)
            {
               if (assoc.isCollection())
               {
                  instanceList = new InstanceArrayList();
                  instanceList.setAssociation(container, assoc, true);
                  instanceList.setLazy(false);
                  container.setOldValueDirect(assoc.getOrdinal(), instanceList);
               }
               else
               {
                  instanceList = null;


                  if (oid == null)
                  {
                     container.setOldValueDirect(assoc.getOrdinal(), null);
                  }
               }
            }
            else
            {
               if (assoc.isCollection() && !(value instanceof Undefined))
               {
                  instanceList = (InstanceList)value;
                  instanceList.setLazy(false);
               }
               else
               {
                  instanceList = null;
                  bAdd = false;
               }
            }
         }


         Metaclass metaclass;


         if (bIdentity)
         {
            if (oid == null)
            {
               if (query.getRoot() == m_query)
               {
                  m_instanceArray[query.getOrdinal()] = null;
               }


               continue;
            }


            if (query.getRoot() != m_query && !query.isLazy())
            {
               if (!bSkipInstance)
               {
                  query.addParentInstance(container, oid);
               }


               continue;
            }


            Field field = query.getTypeCodeField();


            if (field != null)
            {
               metaclass = query.getPersistenceMapping().findMetaclassByTypeCode(getValue(field));


               if (metaclass == null)
               {
                  m_instanceArray[query.getOrdinal()] = null;


                  continue;
               }
            }
            else
            {
               metaclass = getMetaclass(query);
            }
         }
         else
         {
            metaclass = getMetaclass(query);
         }


         InstanceRef ref = m_query.getInvocationContext().findInstanceRef(metaclass, oid);
         Instance instance = (ref == null) ? null : ref.getInstance();


         // Check if the instance has already been retrieved
         if (instance != null)
         {
            // Already retrieved instance
            if (instance.isLazy())
            {
               if (query.isLazy())
               {
                  if (!metaclass.isUpcast(instance.getLazyMetaclass()))
                  {
                     instance.setLazyMetaclass(metaclass);
                  }
               }
               else
               {
                  instance.setMetaclass(metaclass);
               }
            }


            if (instanceList != null)
            {
               bAdd = !instanceList.contains(instance);


               if (bAdd &&
                  container == null &&
                  m_nMaxCount >= 0 &&
                  instanceList.getCount() == m_nOffset + m_nMaxCount)
               {
                  m_bEOF = bDiscardExtra;
                  m_bEOP = !bDiscardExtra;


                  return false;
               }
            }


            if (bAdd)
            {
               switch (instance.getState())
               {
                  case Instance.DELETED:
                     bAdd = false;
                     break;


                  case Instance.DIRTY:
                     if (reverse != null)
                     {
                        Object reverseValue = instance.getValueDirect(reverse.getOrdinal());


                        if (reverseValue != Undefined.VALUE && reverseValue != container)
                        {
                           bAdd = false;
                        }
                     }


                     break;
               }


               if (!bAdd && instanceList == null)
               {
                  if (container.getValueDirect(assoc.getOrdinal()) == Undefined.VALUE)
                  {
                     // Set the new value to null, old value to the retrieved instance
                     container.setValueDirect(assoc.getOrdinal(), null);
                  }


                  bAdd = true;
               }
            }


            if (m_instanceSet.get(query, instance) == null)
            {
               // Merge the not yet retrieved attribute values


               if (!bSkipInstance)
               {
                  // Overwrite only if the instance is clean
                  boolean bOverwrite = (instance.getUnitOfWork() == null);
                  Field lockingField = query.getLockingField();


                  if (lockingField != null)
                  {
                     Attribute lockingAttribute = lockingField.getAttribute();
                     Object oldValue = instance.getNewValueDirect(lockingAttribute.getOrdinal());


                     if (oldValue != Undefined.VALUE)
                     {
                        // Check the old lock value
                        Primitive primitive = (Primitive)lockingAttribute.getType();
                        Object value = getValue(lockingField);


                        if (((Boolean)primitive.findNEFunction(primitive).invoke(oldValue, value)).booleanValue())
                        {
                           // The lock values do not match
                           // If the instance is dirty/deleted or share-locked, throw an exception
                           if (!bOverwrite || ref.isLocked())
                           {
                              throw new OptimisticLockException(instance);
                           }


                           // Discard all the instance attributes
                           for (int i = 0, n = metaclass.getInstanceAttributeCount(); i != n; ++i)
                           {
                              discard(instance, metaclass.getInstanceAttribute(i));
                           }


                           instance.setOldValueDirect(lockingAttribute.getOrdinal(), value);
                        }
                        else
                        {
                           if (bOverwrite)
                           {
                              discard(instance, query);


                              if (reverse != null && bAdd && !instance.isLazy())
                              {
                                 instance.setValueDirect(reverse.getOrdinal(), container);
                              }


                              bOverwrite = false;
                           }
                        }
                     }
                     else
                     {
                        // If the instance is clean, discard the
                        // instance assocs referenced in this query
                        if (bOverwrite)
                        {
                           discard(instance, query);
                        }
                     }
                  }
                  else
                  {
                     // If the instance is clean, discard the
                     // instance assocs referenced in this query
                     if (bOverwrite)
                     {
                        discard(instance, query);
                     }
                  }


                  if (bOverwrite && reverse != null && bAdd && !instance.isLazy())
                  {
                     instance.setValueDirect(reverse.getOrdinal(), container);
                  }


                  addInstance(instance, ref, metaclass, query, bOverwrite);
               }
            }
         }
         else
         {
            // New instance


            if (container == null &&
               m_nMaxCount >= 0 &&
               instanceList.getCount() == m_nOffset + m_nMaxCount)
            {
               m_bEOF = bDiscardExtra;
               m_bEOP = !bDiscardExtra;


               return false;
            }


            instance = new Instance(metaclass, query.isLazy(), m_query.getInvocationContext());
            ref = instance.cache(oid);


            if (!bSkipInstance)
            {
               addInstance(instance, ref, metaclass, query, true);
            }
         }


         if (bAdd)
         {
            if (instanceList != null)
            {
               instanceList.add(instance, InstanceList.DIRECT);
            }
            else
            {
               container.setOldValueDirect(assoc.getOrdinal(), instance);
            }

View Full Code Here

Examples of shared.InstanceList

    // Create Attribute Information on label
    AttrInfo labelAttrib = new NominalAttrInfo(PERFORMANCE_CLASS, perfClasses);


    // Create MLJ meta information
    schema = new Schema(attrInfos, labelAttrib);
    InstanceList instances = createInstances(trainingData, attribMap);


    // Train categoriser
    Categorizer categorizer = getCategorizer(instances);


    // Build predictor

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.