- scheduler - Variable in class de.rcblum.stream.deck.items.animation.Animator
-
Scheduler, that delivers the frames to the stream deck in the frame rate
given by
Animator.animation
- sdImage - Variable in class de.rcblum.stream.deck.util.SDImage
-
Image data for the stream deck
- SDImage - Class in de.rcblum.stream.deck.util
-
Class that contains the image data for the StreamDeck and the Image in a
format that can be displayed on pc
MIT License
Copyright (c) 2017 Roland von Werden
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
- SDImage(byte[], BufferedImage) - Constructor for class de.rcblum.stream.deck.util.SDImage
-
- sendPool - Variable in class de.rcblum.stream.deck.device.StreamDeck
-
Queue for commands to be sent to the ESD
- sendWorker - Variable in class de.rcblum.stream.deck.device.StreamDeck
-
Daemon that send commands to the ESD
- serialVersionUID - Static variable in class de.rcblum.stream.deck.event.KeyEvent
-
- setAnimation(AnimationStack) - Method in class de.rcblum.stream.deck.items.AbstractStreamItem
-
- setAnimation(AnimationStack) - Method in interface de.rcblum.stream.deck.items.StreamItem
-
Sets the animation of the item
- setAnimationTrigger(AnimationTrigger) - Method in class de.rcblum.stream.deck.items.animation.AnimationStack
-
- setBrightness(int) - Method in interface de.rcblum.stream.deck.device.IStreamDeck
-
Sets the desired brightness from 0 - 100 % and queues the change.
- setBrightness(int) - Method in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- setBrightness(int) - Method in class de.rcblum.stream.deck.device.StreamDeck
-
- setBrightness(int) - Method in class de.rcblum.stream.deck.StreamDeckController
-
Wrapper to set brightness of stream deck
- setEndAnimationImmediate(boolean) - Method in class de.rcblum.stream.deck.items.animation.AnimationStack
-
Sets if the animation should be stopped immediate after the trigger is not
applicable anymore.
- setFolderName(String) - Method in class de.rcblum.stream.deck.items.FolderItem
-
- setFrames(SDImage[]) - Method in class de.rcblum.stream.deck.items.animation.AnimationStack
-
Sets the frames for the animation
- setIcon(SDImage) - Method in class de.rcblum.stream.deck.items.AbstractStreamItem
-
- setIcon(SDImage) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setIcon(SDImage) - Method in interface de.rcblum.stream.deck.items.StreamItem
-
Sets the icon for the item.
- setIconPackage(IconPackage) - Method in class de.rcblum.stream.deck.items.AbstractStreamItem
-
- setIconPackage(IconPackage) - Method in interface de.rcblum.stream.deck.items.StreamItem
-
Apply the icon and animation of the
IconPackage
to the item
- setKeyDeadzone(long) - Static method in class de.rcblum.stream.deck.StreamDeckController
-
Sets the key dead zone.
- setName(String) - Method in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- setParent(StreamItem) - Method in class de.rcblum.stream.deck.items.AbstractStreamItem
-
- setParent(StreamItem) - Method in class de.rcblum.stream.deck.items.PagedFolderItem.NextItem
-
- setParent(StreamItem) - Method in class de.rcblum.stream.deck.items.PagedFolderItem.PreviousItem
-
- setParent(StreamItem) - Method in class de.rcblum.stream.deck.items.PagedFolderItem
-
- setParent(StreamItem) - Method in class de.rcblum.stream.deck.items.PreviousItem
-
- setParent(StreamItem) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setParent(StreamItem) - Method in interface de.rcblum.stream.deck.items.StreamItem
-
- setRoot(StreamItem) - Method in class de.rcblum.stream.deck.StreamDeckController
-
Sets a new root folder and opens it
- setSelected(boolean) - Method in class de.rcblum.stream.deck.items.ToggleItem
-
- setText(String) - Method in class de.rcblum.stream.deck.items.AbstractStreamItem
-
- setText(String) - Method in class de.rcblum.stream.deck.items.animation.AnimationStack
-
Sets the text to be displayed on the animation
- setText(String) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setText(String) - Method in interface de.rcblum.stream.deck.items.StreamItem
-
Sets the text to be displayed of the item.
- setTextLine1(String, int) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setTextLine2(String, int) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setTextLine3(String, int) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setTextPos(int) - Method in class de.rcblum.stream.deck.items.animation.AnimationStack
-
Sets the text position of the displayed text
- setTextPosition(int) - Method in class de.rcblum.stream.deck.items.AbstractStreamItem
-
- setTextPosition(int) - Method in class de.rcblum.stream.deck.items.ProxyItem
-
- setTextPosition(int) - Method in interface de.rcblum.stream.deck.items.StreamItem
-
Position of the displayed text.
- showDecks() - Static method in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- SOFT_STREAM_DECKS - Static variable in class de.rcblum.stream.deck.device.StreamDeckDevices
-
- SoftStreamDeck - Class in de.rcblum.stream.deck.device
-
MIT License
Copyright (c) 2017 Roland von Werden
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
- SoftStreamDeck(String, IStreamDeck) - Constructor for class de.rcblum.stream.deck.device.SoftStreamDeck
-
- SoftStreamDeck.DragListener - Class in de.rcblum.stream.deck.device
-
- SoftStreamDeck.DrawDaemon - Class in de.rcblum.stream.deck.device
-
- SoftStreamDeck.EventDispatcher - Class in de.rcblum.stream.deck.device
-
Dispatcher that asynchronously sends out all issued
KeyEvent
s.
- SoftStreamDeck.IconUpdate - Class in de.rcblum.stream.deck.device
-
- SoftStreamDeck.KeyListener - Class in de.rcblum.stream.deck.device
-
- SoftStreamDeck.WriteDaemon - Class in de.rcblum.stream.deck.device
-
- splitText(String, FontMetrics) - Static method in class de.rcblum.stream.deck.util.IconHelper
-
Splits the text so no line is longer than an icon is wide
- start() - Method in class de.rcblum.stream.deck.items.animation.Animator
-
Starts the animation
- startThreads() - Method in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- stop() - Method in interface de.rcblum.stream.deck.device.IStreamDeck
-
Tells the background task for the stream deck to stop working.
- stop() - Method in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- stop() - Method in class de.rcblum.stream.deck.device.StreamDeck
-
- stop(boolean) - Method in class de.rcblum.stream.deck.items.animation.Animator
-
Stops the animation.
- stop(boolean, boolean) - Method in class de.rcblum.stream.deck.StreamDeckController
-
Stops the update by animators on the streamdeck and the streamdeck itself
- stopAfterAnimation - Variable in class de.rcblum.stream.deck.items.animation.Animator
-
Flag to indicate, that the animation should be stopped afuter the
animation finished.
- stopThreads() - Method in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- STREAM_DECK_DEVICES - Static variable in class de.rcblum.stream.deck.device.StreamDeckDevices
-
- STREAM_DECK_INFOS - Static variable in class de.rcblum.stream.deck.device.StreamDeckDevices
-
- STREAM_DECKS - Static variable in class de.rcblum.stream.deck.device.StreamDeckDevices
-
- StreamButton - Class in de.rcblum.stream.deck.deprecated
-
Deprecated.
- StreamButton(int, Color, HidDevice) - Constructor for class de.rcblum.stream.deck.deprecated.StreamButton
-
Deprecated.
- streamDeck - Variable in class de.rcblum.stream.deck.deprecated.StreamButton
-
Deprecated.
- streamDeck - Variable in class de.rcblum.stream.deck.device.SoftStreamDeck
-
- streamDeck - Variable in class de.rcblum.stream.deck.items.animation.Animator
-
Stream Deck that conatins the key on which the animation should be
displayed
- streamDeck - Variable in class de.rcblum.stream.deck.StreamDeckController
-
Proxy for interacting with the ESD
- StreamDeck - Class in de.rcblum.stream.deck.device
-
Provides low level access to a connected stream deck.
- StreamDeck(HidDevice, int, int) - Constructor for class de.rcblum.stream.deck.device.StreamDeck
-
Creates a wrapper for the Stream Deck HID
- StreamDeck.BrightnessUpdater - Class in de.rcblum.stream.deck.device
-
- StreamDeck.DeckWorker - Class in de.rcblum.stream.deck.device
-
- StreamDeck.EventDispatcher - Class in de.rcblum.stream.deck.device
-
Dispatcher that asynchronously sends out all issued
KeyEvent
s.
- StreamDeck.IconUpdater - Class in de.rcblum.stream.deck.device
-
Sends an Icon to a given key on the ESD.
- StreamDeck.Resetter - Class in de.rcblum.stream.deck.device
-
Sends the reset command to the ESD.
- StreamDeckController - Class in de.rcblum.stream.deck
-
Can be used to hand over control over the stream deck by providing a "folder"
structure.
- StreamDeckController(IStreamDeck, StreamItem) - Constructor for class de.rcblum.stream.deck.StreamDeckController
-
Creates the StreamDeckController with a root folder and the ESD
- StreamDeckDevices - Class in de.rcblum.stream.deck.device
-
MIT License
Copyright (c) 2017 Roland von Werden
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
- StreamDeckDevices() - Constructor for class de.rcblum.stream.deck.device.StreamDeckDevices
-
- StreamItem - Interface in de.rcblum.stream.deck.items
-
Interface to bind actions to a key of a stream deck.
- StreamKeyListener - Interface in de.rcblum.stream.deck.event
-
MIT License
Copyright (c) 2017 Roland von Werden
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
- syncLock - Static variable in class de.rcblum.stream.deck.items.animation.Animator
-


AMP content should appear within table, but is rendered before.
AMP list content should appear after header, but is rendered before.


Current Speed: {{sliderVal1}}
Current Speed: {{sliderVal2}}
Current Speed: {{sliderVal3}}
Current Speed: {{sliderVal4}}
Current Speed: {{sliderVal5}}
Current Speed: {{sliderVal6}}
Current Speed: {{sliderVal7}}
Current Speed: {{sliderVal8}}
Turn on/off DAC button to play and remix music
If you dont listen music, please use google chorme which is highly recommended
Even if you dont listen music, make it sure all of the elements are in teh database and use command -MusicMachine.find().fetch()- in your client
You can insert missing element by using - MusicMachine.update({ _id: 'HNaHtwDiCoSzDQudH'}, {$set: {slide7: 10}});- Please change id according to your session.
Please make it sure these help steps are in coursera project for developers.
Last but not leaste you can check the following link either your browser support web api or not
Enjoy.............
Enter Again... :)


public class VEventUserAgent extends AbstractUserAgent<VEvent>
| Constructor and Description |
|---|
VEventUserAgent(ProdId prodId,
Organizer organizer,
UidGenerator uidGenerator) |
| Modifier and Type | Method and Description |
|---|---|
Calendar |
add(VEvent component)
3.2.4.
|
Calendar |
cancel(VEvent... component)
3.2.5.
|
Calendar |
counter(Calendar request)
3.2.7.
|
Calendar |
declineCounter(Calendar counter)
3.2.8.
|
Calendar |
delegate(Calendar request)
<IP_ADDRESS>.
|
Calendar |
publish(VEvent... component)
3.2.1.
|
Calendar |
refresh(VEvent component)
3.2.6.
|
Calendar |
reply(Calendar request)
3.2.3.
|
Calendar |
request(VEvent... component)
3.2.2.
|
getProdId, transform, wrap
public VEventUserAgent(ProdId prodId, Organizer organizer, UidGenerator uidGenerator)
public Calendar publish(VEvent... component)
3.2.1. PUBLISH The "PUBLISH" method in a "VEVENT" calendar component is an unsolicited posting of an iCalendar object. Any CU may add published components to their calendar. The "Organizer" MUST be present in a published iCalendar component. "Attendees" MUST NOT be present. Its expected usage is for encapsulating an arbitrary event as an iCalendar object. The "Organizer" may subsequently update (with another "PUBLISH" method), add instances to (with an "ADD" method), or cancel (with a "CANCEL" method) a previously published "VEVENT" calendar component.
component
- one or more component objectspublic Calendar request(VEvent... component)
3.2.2. REQUEST The "REQUEST" method in a "VEVENT" component provides the following scheduling functions: o Invite "Attendees" to an event. o Reschedule an existing event. o Response to a "REFRESH" request. o Update the details of an existing event, without rescheduling it. o Update the status of "Attendees" of an existing event, without rescheduling it. o Reconfirm an existing event, without rescheduling it. o Forward a "VEVENT" to another uninvited CU. o For an existing "VEVENT" calendar component, delegate the role of "Attendee" to another CU. o For an existing "VEVENT" calendar component, change the role of "Organizer" to another CU. The "Organizer" originates the "REQUEST". The recipients of the "REQUEST" method are the CUs invited to the event, the "Attendees". "Attendees" use the "REPLY" method to convey attendance status to the "Organizer". The "UID" and "SEQUENCE" properties are used to distinguish the various uses of the "REQUEST" method. If the "UID" property value in the "REQUEST" is not found on the recipient's calendar, then the "REQUEST" is for a new "VEVENT" calendar component. If the "UID" property value is found on the recipient's calendar, then the "REQUEST" is for a rescheduling, an update, or a reconfirmation of the "VEVENT" calendar component. For the "REQUEST" method, multiple "VEVENT" components in a single iCalendar object are only permitted for components with the same "UID" property. That is, a series of recurring events may have instance-specific information. In this case, multiple "VEVENT" components are needed to express the entire series.
component
- one or more component objectspublic Calendar delegate(Calendar request)
UserAgent
<IP_ADDRESS>. Delegating an Event to Another CU Some calendar and scheduling systems allow "Attendees" to delegate their presence at an event to another "Calendar User". iTIP supports this concept using the following workflow. Any "Attendee" may delegate their right to participate in a calendar "VEVENT" to another CU. The implication is that the delegate participates in lieu of the original "Attendee", NOT in addition to the "Attendee". The delegator MUST notify the "Organizer" of this action using the steps outlined below. Implementations may support or restrict delegation as they see fit. For instance, some implementations may restrict a delegate from delegating a "REQUEST" to another CU. The "Delegator" of an event forwards the existing "REQUEST" to the "Delegate". The "REQUEST" method MUST include an "ATTENDEE" property with the calendar address of the "Delegate". The "Delegator" MUST also send a "REPLY" method to the "Organizer" with the "Delegator's" "ATTENDEE" property "PARTSTAT" parameter value set to "DELEGATED". In addition, the "DELEGATED-TO" parameter MUST be included with the calendar address of the "Delegate". Also, a new "ATTENDEE" property for the "Delegate" MUST be included and must specify the calendar user address set in the "DELEGATED-TO" parameter, as above. In response to the request, the "Delegate" MUST send a "REPLY" method to the "Organizer", and optionally to the "Delegator". The "REPLY" method SHOULD include the "ATTENDEE" property with the "DELEGATED- FROM" parameter value of the "Delegator's" calendar address. The "Delegator" may continue to receive updates to the event even though they will not be attending. This is accomplished by the "Delegator" setting their "role" attribute to "NON-PARTICIPANT" in the "REPLY" to the "Organizer".
request
- a calendar implement the iTIP REQUEST methodpublic Calendar reply(Calendar request)
3.2.3. REPLY The "REPLY" method in a "VEVENT" calendar component is used to respond (e.g., accept or decline) to a "REQUEST" or to reply to a delegation "REQUEST". When used to provide a delegation response, the "Delegator" SHOULD include the calendar address of the "Delegate" on the "DELEGATED-TO" property parameter of the "Delegator's" "ATTENDEE" property. The "Delegate" SHOULD include the calendar address of the "Delegator" on the "DELEGATED-FROM" property parameter of the "Delegate's" "ATTENDEE" property. The "REPLY" method is also used when processing of a "REQUEST" fails. Depending on the value of the "REQUEST-STATUS" property, no scheduling action may have been performed. The "Organizer" of an event may receive the "REPLY" method from a CU not in the original "REQUEST". For example, a "REPLY" may be received from a "Delegate" to an event. In addition, the "REPLY" method may be received from an unknown CU (a "Party Crasher"). This uninvited "Attendee" may be accepted, or the "Organizer" may cancel the event for the uninvited "Attendee" by sending a "CANCEL" method to the uninvited "Attendee". An "Attendee" MAY include a message to the "Organizer" using the "COMMENT" property. For example, if the user indicates tentative acceptance and wants to let the "Organizer" know why, the reason can be expressed in the "COMMENT" property value. The "Organizer" may also receive a "REPLY" from one CU on behalf of another. Like the scenario enumerated above for the "Organizer", "Attendees" may have another CU respond on their behalf. This is done using the "SENT-BY" parameter. The optional properties listed in the table below (those listed as "0+" or "0 or 1") MUST NOT be changed from those of the original request. If property changes are desired, the "COUNTER" message must be used.
request
- a calendar requestpublic Calendar add(VEvent component)
3.2.4. ADD The "ADD" method allows the "Organizer" to add one or more new instances to an existing "VEVENT" using a single iTIP message without having to send the entire "VEVENT" with all the existing instance data, as it would have to do if the "REQUEST" method were used. The "UID" must be that of the existing event. If the "UID" property value in the "ADD" is not found on the recipient's calendar, then the recipient SHOULD send a "REFRESH" to the "Organizer" in order to be updated with the latest version of the "VEVENT". If an "Attendee" implementation does not support the "ADD" method, it should respond with a "REQUEST-STATUS" value of 3.14 and ask for a "REFRESH". When handling an "ADD" message, the "Attendee" treats each component in the "ADD" message as if it were referenced via an "RDATE" in the main component.
component
- a calendar component to addpublic Calendar cancel(VEvent... component)
3.2.5. CANCEL The "CANCEL" method in a "VEVENT" calendar component is used to send a cancellation notice of an existing event request to the affected "Attendees". The message is sent by the "Organizer" of the event. For a recurring event, either the whole event or instances of an event may be cancelled. To cancel the complete range of a recurring event, the "UID" property value for the event MUST be specified and a "RECURRENCE-ID" MUST NOT be specified in the "CANCEL" method. In order to cancel an individual instance of the event, the "RECURRENCE-ID" property value for the event MUST be specified in the "CANCEL" method. There are two options for canceling a sequence of instances of a recurring "VEVENT" calendar component: a. The "RECURRENCE-ID" property for an instance in the sequence MUST be specified with the "RANGE" property parameter value of "THISANDFUTURE" to indicate cancellation of the specified "VEVENT" calendar component and all instances after. b. Individual recurrence instances may be cancelled by specifying multiple "VEVENT" components each with a "RECURRENCE-ID" property corresponding to one of the instances to be cancelled. The "Organizer" MUST send a "CANCEL" message to each "Attendee" affected by the cancellation. This can be done using a single "CANCEL" message for all "Attendees" or by using multiple messages with different subsets of the affected "Attendees" in each. When a "VEVENT" is cancelled, the "SEQUENCE" property value MUST be incremented as described in Section 2.1.4.
component
- one or more component objectspublic Calendar refresh(VEvent component)
3.2.6. REFRESH The "REFRESH" method in a "VEVENT" calendar component is used by "Attendees" of an existing event to request an updated description from the event "Organizer". The "REFRESH" method must specify the "UID" property of the event to update. A recurrence instance of an event may be requested by specifying the "RECURRENCE-ID" property corresponding to the associated event. The "Organizer" responds with the latest description and version of the event.
component
- a calendar component to refreshpublic Calendar counter(Calendar request)
3.2.7. COUNTER The "COUNTER" method for a "VEVENT" calendar component is used by an "Attendee" of an existing event to submit to the "Organizer" a counter proposal to the event. The "Attendee" sends this message to the "Organizer" of the event. The counter proposal is an iCalendar object consisting of a "VEVENT" calendar component that provides the complete description of the alternate event. The "Organizer" rejects the counter proposal by sending the "Attendee" a "DECLINECOUNTER" method. The "Organizer" accepts the counter proposal by rescheduling the event as described in Section <IP_ADDRESS>, "Rescheduling an Event". The "Organizer's" CUA SHOULD send a "REQUEST" message to all "Attendees" affected by any change triggered by an accepted "COUNTER".
request
- a calendar request to counterpublic Calendar declineCounter(Calendar counter)
3.2.8. DECLINECOUNTER The "DECLINECOUNTER" method in a "VEVENT" calendar component is used by the "Organizer" of an event to reject a counter proposal submitted by an "Attendee". The "Organizer" must send the "DECLINECOUNTER" message to the "Attendee" that sent the "COUNTER" method to the "Organizer".
counter
- a counter to a request


This guide references the following value sets. Note: value sets defined in the base Composition resource are not included in this list.
| Name | Definition |
| DischargeSummaryDocumentTypeCode | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.1 A value set of LOINC document codes for discharge summaries. Specific URL Pending |
| ConsultDocumentType | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.31 Specific URL Pending |
| ReferralDocumentType | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.2.3 A referral note provides a consulting physician specified patient information about the patient referred. Specific URL Pending |
| ProcedureNoteDocumentTypeCodes | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.1 A value set of LOINC document codes for Procedure Notes. Specific URL Pending |
| HPDocumentType | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.22 Specific URL Pending |
| LOINC Imaging Document Codes | http://hl7.org/fhir/ccda/ValueSet/<IP_ADDRESS>.4.1.12<IP_ADDRESS> A value set of LOINC document type codes for Diagnostic Imaging Reports. |
| DIRSectionTypeCodes | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.59 The Section Type codes used by DIR are all narrative document sections. The codes in this table are drawn from LOINC (http://www.loinc.org/) and DICOM (http://medical.nema.org/). The section/code should be selected from LOINC or DICOM for sections not listed in this table. |
| SurgicalOperationNoteDocumentTypeCode | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.1 Specific URL Pending |
| ProgressNoteDocumentTypeCode | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.1 Specific URL Pending |
| TransferDocumentType | http://hl7.org/fhir/ccda/ValueSet/2.16.840.1.1138<IP_ADDRESS>.2.4 A transfer document is exchanged between care providers when a patient transfers from one care setting to another. This value set includes all LOINC codes whose Component = Transfer Summary Note* and SCALE_TYPE = Doc. |


Qt Positioning C++ Classes
The Positioning module provides positioning information via QML and C++ interfaces. More...
Classes
Represents an address of a QGeoLocation | |
Describes the parameters of an area or region to be monitored for proximity | |
Enables the detection of proximity changes for a specified set of coordinates | |
Defines a circular geographic area | |
Defines a geographical position on the surface of the Earth | |
Represents basic information about a location | |
Defines a geographic path | |
Contains information gathered on a global position, direction and velocity at a particular point in time | |
Abstract base class for the distribution of positional updates | |
Factory class used as the plugin interface for external providers of positioning data | |
Defines a rectangular geographic area | |
Contains basic information about a satellite | |
Abstract base class for the distribution of satellite information updates | |
Defines a geographic area | |
Positional information using a NMEA data source |
Detailed Description
To load the Qt Positioning module, add the following statement to your .qml files
import QtPositioning 5.2
For C++ projects include the header appropriate for the current use case, for example applications using routes may use
#include <QGeoCoordinate>
The .pro file should have the positioning keyword added
QT += positioning
See more in the Qt Positioning Overview.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit | |
|---|---|
| de.uni.bamberg.wiai.minf.forflow.datagenerator.controller | Represents the controller of the MVC pattern; it's not allowed to get access to the data model directly, instead use this package to do so. |
| de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit | A unit is a standardized weight or measurement that describes the generated entity more precisly. |
| de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.io | Everything that has to do with serialization or deserialization is in this package. |
| de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.worker | Long running background tasks for I/O, database or any other computational intensive task are separated from the EDT. |
| de.uni.bamberg.wiai.minf.forflow.datagenerator.model | Represents the data model of MVC pattern; therefore, the data structures used in this application are stored here. |
| de.uni.bamberg.wiai.minf.forflow.datagenerator.view | Represents the view of the MVC pattern and interacts with the user through a UI. |
| Classes in de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit used by de.uni.bamberg.wiai.minf.forflow.datagenerator.controller | |
|---|---|
| Custom
Customized class to represent weight and measurements. |
|
| ObservableUnit
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObservableUnitCustom
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObserverUnit
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObserverUnitCustom
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| Unit
An unit is a standard of a weight or a measurement. |
| Classes in de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit used by de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit | |
|---|---|
| Currency
This is the unit of currency. |
|
| Custom
Customized class to represent weight and measurements. |
|
| Length
This is the unit of length. |
|
| Mass
This is the unit of mass. |
|
| Math
It's the unit of math. |
|
| Miscellaneous
Here are the units gathered, which do not fit into any other category. |
|
| ObservableUnit
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObservableUnitCustom
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObserverUnit
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObserverUnitCustom
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| Temperature
This is the unit of temperature. |
|
| Time
A class to represent units in time. |
|
| Unit
An unit is a standard of a weight or a measurement. |
|
| WeightAndMeasurement
The intention behind this interface is to model weights and measurement not fitting into one of the other units. |
|
| WeightAndMeasurementCustomized
The intention behind this interface is to model weights and measurement not fitting into one of the other units. |
| Classes in de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit used by de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.io | |
|---|---|
| Unit
An unit is a standard of a weight or a measurement. |
| Classes in de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit used by de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.worker | |
|---|---|
| Custom
Customized class to represent weight and measurements. |
| Classes in de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit used by de.uni.bamberg.wiai.minf.forflow.datagenerator.model | |
|---|---|
| Unit
An unit is a standard of a weight or a measurement. |
| Classes in de.uni.bamberg.wiai.minf.forflow.datagenerator.controller.datageneration.unit used by de.uni.bamberg.wiai.minf.forflow.datagenerator.view | |
|---|---|
| Custom
Customized class to represent weight and measurements. |
|
| ObserverUnit
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
| ObserverUnitCustom
To be able to update the weight and measurements whenever a change in the data structure happens, we use Observer Pattern to get the desired effect. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Mounts the specified directory into minikube.
minikube mount [flags] <source directory>:<target directory> [options]
Use "minikube options" for a list of global command-line options (applies to all commands).


9to5Mac Daily: November 20, 2019 – Holiday gift guide with Zac Hall
by Chance MillerListen to a recap of the top stories of the day from 9to5Mac. 9to5Mac Daily is available on iTunes and Apple’s Podcasts app, Stitcher, TuneIn, Google Play, or through our dedicated RSS feed for Overcast and other podcast players.
Sponsored by Hyper: Preorder the new HyperJuice, the world’s smallest 100W GaN USB-C charger 40% off for a limited time.
New episodes of 9to5Mac Daily are recorded every weekday. Subscribe to our podcast in iTunes/Apple Podcast or your favorite podcast player to guarantee new episodes are delivered as soon as they’re available.
Stories discussed in this episode:
Enjoy the podcast?:
Shop Apple at Amazon to support 9to5Mac Daily!
Follow Chance:
Follow Zac:
Listen & Subscribe:
Share your thoughts!
Drop us a line at<EMAIL_ADDRESS>You can also rate us in Apple Podcasts or recommend us in Overcast to help more people discover the show!
FTC: We use income earning auto affiliate links. More.


Wedding guest bus thug bottled guest in the face
Row broke out on wedding bus travelling to Renfrewshire
by Ron Moore, https://www.dailyrecord.co.uk/authors/ron-moore/A tanked-up guest bottled another reveller in the face after trouble flared up on a wedding bus.
Ross Nisbet, 26, attacked victim Andrew Miller with a glass bottle after they clashed on board a coach travelling to Renfrewshire.
Paisley Sheriff Court heard Nisbet sat down behind Mr Miller before producing the bottle, which he smashed into his face, leaving him scarred for life.
Procurator Fiscal depute John Penman told the court Nisbet and Mr Miller got into an argument over seating on the bus travelling back to Johnstone from Bathgate following the wedding.

“Mr Miller asked the accused to move as both he and his partner were feeling ‘squashed.’
“The accused apparently refused to move.
“The witness Mr Miller got up to move to another seat.
“The witness then approached the accused, and the accused is pushed off of the seat by the complainer.
“The accused moved to another seat behind the complainer.
“There was a verbal exchange between them. After about 15 to 20 minutes the accused struck the complainer on the head with a glass bottle.”
The court heard the attack happened as the bus was pulling into Johnstone railway station in the early hours of November 30 last year.
A number of eyewitnesses travelling on the bus clocked the assault.
The prosecutor added: “Mr Miller had his back to the accused. He feels being struck on the head and as he got up he observes the accused standing up pointing at him.”
Mr Miller was left with blood streaming from wounds in his face.
He was taken to Paisley’s Royal Alexandra Hospital by ambulance and received stitches to wounds both above and beneath his left eye.
He also suffered a gash in his left ear and another cut on his cheek.
Yesterday, Nisbet of Canal Street, Johnstone, admitted a charge of assault to severe injury and permanent disfigurement.
Defence agent Gordon Nicol said Nisbet acted only after “provocation” from Mr Miller, who had pushed him off the seat causing him to fall onto the passageway in the bus “in front of everyone.”
He said: “He admits it was a moment of madness when he committed this offence. This will live with him for the rest of his days.
“It is a significant conviction on his record and he accepts his conduct was unacceptable.”
Sheriff Craig Harris said: “This is an exceptionally serious offence involving an assault upon another by striking him on the head while he had been sitting down.”
However, he said he was prepared to deal with the matter by handing Nisbet a punishment as an “alternative to custody” because of his lack of a serious record, and his admission of guilt.
He handed him 12 months of supervision, ordered him to perform 270 hours of unpaid work and told him to pay £3,000 in compensation to the victim.


--- title: "Creating excel workbooks in R" author: "Corey Pembleton" date: "2018-08-25" output: html_document categories: ["R", "Tutorial"] tags: ["openxlsx"] thumbnailImagePosition: "left" thumbnailImage: "/img/open-xlsx-example.png" ---
Reading Time: 2 minutes
I’m not exactly fundamentally against Microsoft Excel, but I’m not a member of the fan club either, so to speak. But when it comes to giving the people what they want, be it cake or be it proprietary spreadsheet softwares, I have to oblige. And ultimately what really matters at the end of the day is that the user, and client has the desired end result, not what I prefer as a datascientist. Thus, an important component of datascience is a) giving clients their desired output, and b) ensuring it is an output best suited to their needs - and sometimes that means giving an output in the form of an excel workbook.
openxlsx
is a very convenient package which provides a high degree of functionality for created formatted excel workbooks, complete with all the bells and whistles excel users desire, such as expanding columns. wihle you can easily output a list of tibbles with the write.xlsx()
function, this only provides minimal format options.
Alternatively, we can take a list of tibbles, e.g.:
list <- list(cars = cars, WorldPhones = WorldPhones, trees = trees, quakes = quakes)
Establish the various styles desired to be mapped across all worksheets. In this case, I want alternating colours in each column with a unique header style.
hs1 <- createStyle(fontColour = "black", halign = "center", fontName = "Arial",
valign = "center", textDecoration = "bold", fgFill = "white",
border = "TopBottomLeftRight")
lightStyle <- createStyle(fontColour = "black", fgFill = "white", halign = "right",
valign = "center")
darkStyle <- createStyle(fontColour = "black", fgFill = "lightgray",
halign = "right", valign = "center")
Next, create an empty workbook:
wb <- createWorkbook() #create an empty excel workbook
Create a function for processing each of the tibbles into the empty workbook, noting that the order within the functions matters, as styles must be applied following writeData()
.
Map(function(data, name){ #function to loop through the list of objects and apply same formatting
options("openxlsx.dateFormat" = "dd/mm/yyyy")
addWorksheet(wb, name)
writeData(wb, name, data, borders = c("surrounding"),
borderColour = getOption("openxlsx.borderColour", "black"),
borderStyle = getOption("openxlsx.borderStyle", "thin"),
keepNA = FALSE)
colorRows <- 2:(nrow(data)+1)
setColWidths(wb, name, cols = 1:ncol(data), widths = "auto")
addStyle(wb, name, hs1, cols = 1:ncol(data), rows = 1, gridExpand = FALSE)
addStyle(wb, name, lightStyle, rows = colorRows[which(colorRows %% 2 == 0)],
cols = 1:ncol(data), gridExpand = TRUE)
addStyle(wb, name, darkStyle, rows = colorRows[which(colorRows %% 2 == 1)],
cols = 1:ncol(data), gridExpand = TRUE)
}, list, names(list))
And lastly, save the desired output:
saveWorkbook(wb, "excel_workbook.xlsx", TRUE)
Which gives a lovely formatted excel workbook:
I got most of the information for this blog from the very helpful openxlsx
vignettes, from stackoverflow responses, and the idea for mapping the function from a post on Rbloggers. I have to say, my work received immediate postive feedback from clients and colleagues who were very weary about recieving completely unformatted .csv files from me!


I've just added a hard disk to my rpi emoncms setup and installed the Rpi HDD ready built image.
Once It was all setup I ran php import_inputs.php and then php import_full.php to replicate my emoncms.org data I then updated the database in the admin page of my local emoncms.
At this point my local emoncms only showed 4 inactive node 10 inputs but when I deleted these all my inputs appeared and started updating the feeds.
Everything seemed to be working well but when I subsequently rebooted the Rpi I gained an extra twelve duplicate node 10 inputs instead of the original four and the wrong ones where now updating ie the inputs without feeds associated.
I spent a couple of days trying to sort this but then gave up and wiped the disk and re-imaged it and set everything up fresh once again but the problem is still there on the new setup.
Can anyone suggest how I can sort this please.
Re: Solved: New Pi HDD emoncms setup gains extra inputs on every reboot.
hmm, it may be an issue with the input metadata not being in-sync between redis and mysql, I will look into it.
A couple of things to try would be first updating emoncms, there have been a few updates since the last pi image which may help solve the problem.
The other may be to clear redis after running import.
which can be done by typing:
$ redis-cli
and then:
flushall
this will force a reload of all metadata including inputs.
I will see if I can replicate the problem here.
Re: Solved: New Pi HDD emoncms setup gains extra inputs on every reboot.
I checked that Emoncms is up to date and I tried the redis-cli and flushall and then updated the database in Admin but when I rebooted I got another 2 x 4 duplicate inputs again.
Re: Solved: New Pi HDD emoncms setup gains extra inputs on every reboot.
Hi Trystan, thanks for the suggestions. I finally figured out what was happening.... I had modified the raspberrypi_run.php file incorrectly. I had been using a modified raspberrypi_run.php to upload to PVoutput.org for a long time but I tried to add in the latest redis modifications to my existing file and messed up. Since then I have worked backwards and added in the PVoutput mods to the Redis version and it appears to be working properly now. The original PVOutput.org upload mods where posted by nothing clever in this thread.. spam blocker won't let me post links


{% load static %}
SAFE & SECURE :
Both blockchain and image processing used in this application are secure.
ACCURATE : The app is built in such a way that, the
predominance is given to the vote count.
EFFICIENT DATA STORAGE : Data is stored efficiently on
blockchain
Result Analysis like no other.
2 factor authentication :Two factor authentication to make
sure the right person is voting
Online : All the steps are completly online


←Home
Good Job!


Money Play. How should Red play 61?
pips Red=146 White=165
(CorrectAnswer= 0/0, ErrorScore= 0)
Over the board it is very easy to play 16/0, 3/2 but Red can create better flexibility and maintain his home board by playing 16/9.
White is unlikely to be tempted off Red’s 5-pt to hit and then Red’s checkers will be well place to make the 8-pt or bar-pt next turn.
The key is to see that in reality the blots are not in any real danger and even in the sequences where one or both of them are hit Re will be able to re-enter easily.
16/10, 3/2 and 16/10, 4/3 are both errors but not blunders.
White is unlikely to be tempted off Red’s 5-pt to hit and then Red’s checkers will be well place to make the 8-pt or bar-pt next turn.
The key is to see that in reality the blots are not in any real danger and even in the sequences where one or both of them are hit Re will be able to re-enter easily.
16/10, 3/2 and 16/10, 4/3 are both errors but not blunders.
1. Cubeful 2-ply 16/9 Eq.: +0.280 0.585 0.099 0.002 - 0.415 0.064 0.001 2. Cubeful 2-ply 16/10 3/2 Eq.: +0.264 (-0.016) 0.585 0.092 0.002 - 0.415 0.072 0.001 3. Cubeful 2-ply 16/10 4/3 Eq.: +0.248 (-0.032) 0.579 0.092 0.002 - 0.421 0.074 0.001 4. Cubeful 2-ply 13/6 Eq.: +0.213 (-0.068) 0.566 0.102 0.002 - 0.434 0.078 0.002 5. Cubeful 2-ply 13/7 10/9 Eq.: +0.186 (-0.095) 0.556 0.109 0.003 - 0.444 0.084 0.002


| PostgreSQL 9.5.19 Documentation | |||
|---|---|---|---|
| Prev | Up | Appendix E. Release Notes | Next |
Release date: 2019-08-08
This release contains a variety of fixes from 9.5.18. For information about new features in the 9.5 major release, see Section E.20.
A dump/restore is not required for those running 9.5.X.
However, if you are upgrading from a version earlier than 9.5.13, see Section E.7.
Require schema qualification to cast to a temporary type when using functional cast syntax (Noah Misch)
We have long required invocations of temporary functions to explicitly specify the temporary schema, that is pg_temp.func_name(args). Require this as well for casting to temporary types using functional notation, for example pg_temp.type_name(arg). Otherwise it's possible to capture a function call using a temporary object, allowing privilege escalation in much the same ways that we blocked in CVE-2007-2138. (CVE-2019-10208)
Fix failure of ALTER TABLE ... ALTER COLUMN TYPE when altering multiple columns' types in one command (Tom Lane)
This fixes a regression introduced in the most recent minor releases: indexes using the altered columns were not processed correctly, leading to strange failures during ALTER TABLE.
Avoid using unnecessary sort steps for some queries with GROUPING SETS (Andrew Gierth, Richard Guo)
Fix mishandling of multi-column foreign keys when rebuilding a foreign key constraint (Tom Lane)
ALTER TABLE could make an incorrect decision about whether revalidation of a foreign key is necessary, if not all columns of the key are of the same type. It seems likely that the error would always have been in the conservative direction, that is revalidating unnecessarily.
Prevent incorrect canonicalization of date ranges with infinity endpoints (Laurenz Albe)
It's incorrect to try to convert an open range to a closed one or vice versa by incrementing or decrementing the endpoint value, if the endpoint is infinite; so leave the range alone in such cases.
Fix loss of fractional digits when converting very large money values to numeric (Tom Lane)
Fix spinlock assembly code for MIPS CPUs so that it works on MIPS r6 (YunQiang Su)
Make libpq ignore carriage return (\r) in connection service files (Tom Lane, Michael Paquier)
In some corner cases, service files containing Windows-style newlines could be mis-parsed, resulting in connection failures.
Fix pg_dump to ensure that custom operator classes are dumped in the right order (Tom Lane)
If a user-defined opclass is the subtype opclass of a user-defined range type, related objects were dumped in the wrong order, producing an unrestorable dump. (The underlying failure to handle opclass dependencies might manifest in other cases too, but this is the only known case.)
Fix contrib/passwordcheck to coexist with other users of check_password_hook (Michael Paquier)
Fix contrib/sepgsql tests to work under recent SELinux releases (Mike Palmiotto)
Reduce stderr output from pg_upgrade's test script (Tom Lane)
Support building Postgres with Microsoft Visual Studio 2019 (Haribabu Kommi)
In Visual Studio builds, honor WindowsSDKVersion environment variable, if that's set (Peifeng Qiu)
This fixes build failures in some configurations.
Support OpenSSL 1.1.0 and newer in Visual Studio builds (Juan José Santamaría Flecha, Michael Paquier)
Allow make options to be passed down to gmake when non-GNU make is invoked at the top level (Thomas Munro)
Avoid choosing localtime or posixrules as TimeZone during initdb (Tom Lane)
In some cases initdb would choose one of these artificial zone names over the "real" zone name. Prefer any other match to the C library's timezone behavior over these two.
Adjust pg_timezone_names view to show the Factory time zone if and only if it has a short abbreviation (Tom Lane)
Historically, IANA set up this artificial zone with an "abbreviation" like Local time zone must be set--see zic manual page. Modern versions of the tzdb database show -00 instead, but some platforms alter the data to show one or another of the historical phrases. Show this zone only if it uses the modern abbreviation.
Sync our copy of the timezone library with IANA tzcode release 2019b (Tom Lane)
This adds support for zic's new -b slim option to reduce the size of the installed zone files. We are not currently using that, but may enable it in future.
Update time zone data files to tzdata release 2019b for DST law changes in Brazil, plus historical corrections for Hong Kong, Italy, and Palestine.


@* * Copyright 2019 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(scores: connectors.exchange.CandidateScoresAndFeedback, competencyAverageResult: connectors.exchange.CompetencyAverageResult)(implicit request: Request[_], flash: Flash, user: Option[CachedData], feedbackUrl: String, messages: Messages) @candidateName = {
Candidate name: @user.map(_.user.fullName)
Assessment centre
Your performance is measured against six competencies. Each competency is tested at least twice during the centre. We'll calculate an average score to measure your overall performance in each competency, ranging from 1.00 to 4.00.
| Leading & communicating | @{f"${competencyAverageResult.leadingAndCommunicatingAverage}%2.2f"} |
| Collaborating & partnering | @{f"${competencyAverageResult.collaboratingAndPartneringAverage}%2.2f"} |
| Delivering at pace | @{f"${competencyAverageResult.deliveringAtPaceAverage}%2.2f"} |
| Changing & improving | @{f"${competencyAverageResult.changingAndImprovingAverage}%2.2f"} |
| Making effective decisions | @{f"${competencyAverageResult.makingEffectiveDecisionsAverage}%2.2f"} |
| Building capability for all | @{f"${competencyAverageResult.buildingCapabilityForAllAverage}%2.2f"} |
| Motivational fit | @{f"${competencyAverageResult.motivationFitAverage}%2.2f"} |
| 4 | Minor areas for development but provides strong indicators that the candidate would be suitable for the Fast Track. |
| 3 | Some areas for development but also provides indicators that the candidate would be suitable for the Fast Track. |
| 2 | A number of areas for development needed to make the candidate suitable for the Fast Track. |
| 1 | Too many areas for development for the candidate to be suitable for the Fast Track. |
}


Touch the Numbers!
First Choose Your Level:
Easy
Hard
Extreme!
Now Lets Play!
Play
Game Time:
00
:
00
Next Number:


Eduardo Fernandes Montesuma
In this presentation we will cover the ideas behind Optimal Transport in the context of Machine Learning. Some key ideas developed in this presentation are:
Probability: Probability distributions, empirical distributions,
Optimization: Linear Programming and Matrix-Scaling algorithms,
Unsupervised Learning: Clustering, Generative Modeling,
Domain Adaptation: Learning setting when data comes from different probability distributions.
The topics in this lecture range from introductory to intermediate in terms of theory.
Why should we care for probability/statistics?
Supervised Learning
Why should we care for probability/statistics?
Unsupervised Learning
How probability intersects with machine learning? Assume samples come from an unknown underlying distribution.
Formally, (continuous) probability distributions assign probabilities to sets
\[\begin{align} \underset{\scriptsize{\text{Prob. Measure}}}{\mu(E)} &= \underset{\scriptsize{\text{Prob. Distribution}}}{P(X \in E)} \\ &= \int_{E}\underset{\scriptsize{\text{Prob. Density}}}{f(x)}dx \end{align} \]
Note: we do not know \(P\), we only have samples \(\{x_{i}\}_{i=1}^{n}\). Solution: consider that all points have equal probability,
Note that for measuring the probability of a set \(E\), we can simply do,
\[ \mu(E) = \dfrac{1}{n}\sum_{x_{i} \in E}1 \]Optimal Transport is a mathematical theory first developed by the 18-th century French mathematician Gaspard Monge in his mémoirs sur les déblais et les remblais.
An amount of soil needs to be extracted from a source (remblais) and moved to a target (déblais)
Before diving into the theory on how the Monge problem can be solved, let us dive into discretization
Instead of having mass distributed constinuously along the ground, we suppose that it is distributed discretly, \[\mu(x) = \sum_{i=1}^{n}a_{i}\delta(x-x_{i})\]
\(x_{i}\leftarrow\) mass position,
\(a_{i}\leftarrow\) mass weight
Suppose that we have \(\mu\) with locations \(x_{i}\) and weights \(a_{i}\), and \(\nu\) with locations \(y_{j}\) and weights \(b_{j}\). How to transport \(\mu\) into \(\nu\) with least effort?
This question involves the following concepts:
1. A mapping \(T:\mathcal{X}\rightarrow\mathcal{Y}\) that transports masses \(a_{i}\) into \(b_{j}\),
2. A cost \(c:\mathcal{X}\times\mathcal{Y}\) that gives the effort of moving \(x_{i} \in \mathcal{X}\) into \(T(x_{i}) \in \mathcal{Y}\).
The mapping $T$ is called transportation map, or Monge Map. We want to ensure mass conservation, this means that all mass going to \(y_{j}\) needs to come from some \(x_{i}\) (possibly many),
Solution: we define a cost function \(c:\mathcal{X}\times\mathcal{Y}\rightarrow\mathbb{R}\).
Example of costs:
1. Cityblock distance: \(c(x,y) = |x - y|\)
2. Euclidean distance \(c(x,y) = (x - y)^{2}\)
3. p-distances: \(c(x,y) = |x - y|^{p}\)
Hence, the effort of \(T\) is given by \(\sum_{i=1}^{n}c(x_{i}, T(x_{i}))\)
The Monge Mapping is defined through the following optimization problem, \[T^{*} = \underset{b_{j} = \sum_{i:T(x_{i})=y_{j}}a_{i}}{\text{argmin}}\sum_{i=1}^{n}c(x_{i},T(x_{i}))\]
Hence,
1. The Monge Mapping \(T^{*}\) preserves mass.
2. The masses \(a_{i}\) cannot be split. Thus, for \(m > n\), the problem has no solutions.
Suppose that one has images \(I_{1}\) and \(I_{2}\). Each pixel \((i, j)\) is a triple \((r, g, b)\) with color intensities for red, green and blue. we may model each pixel as a point in \(\mathbb{R}^{3}\)
Modeling assumptions: Each pixel \(I_{1}(i, j)\) corresponds to a point \(x_{p} \in \mathbb{R}^{3}\) and each pixel \(I_{2}(i, j)\) corresponds to a point \(y_{q} \in \mathbb{R}^{3}\)
The transportation is done by calculating \(T^{*}\) and applying it to each pixel in \(I_{1}\),
Sometimes \(T^{*}\) is too hard to solve. Can we get a simpler problem? As it turns out, yes!
In the 20-th century, a soviet mathematician called Leonid Kantorovich devised a problem equivalent to Monge's, called Kantorovich problem or Kantorovich formulation of Optimal Transport
Kantorovich's insight was to devise the optimal transportation problem in terms of transportation plan \(\gamma \in \mathbb{R}^{n\times m}\). Intuitively, \(\gamma_{ij}\) tells how much mass is moved from \(x_{i}\) to \(y_{j}\). Since \(\gamma\) needs to preserve mass, one has,
1. \(\sum_{i=1}^{n}\gamma_{ij} = b_{j}\) (all mass from \(b_{j}\) comes from \(\{a_{i}\}_{i=1}^{n}\))
2. \(\sum_{j=1}^{m}\gamma_{ij} = a_{i}\) (all mass from \(a_{i}\) is distributed over \(\{b_{j}\}_{j=1}^{m}\))
These two constraints can be translated into the following set, \[\Pi(\mu, \nu) = \{\gamma \in \mathbb{R}^{n\times m}: \gamma1_{n} = a, \gamma^{T}1_{m} = b\}\]
Using the previous definitions, the Kantorovich formulation of Optimal Transport is given by the following optimization problem, \[\gamma^{*} = \underset{\gamma \in \Pi(\mu, \nu)}{argmin}\sum_{i=1}^{n}\sum_{j=1}^{m}C_{ij}\gamma_{ij}\] where \(C_{ij} = c(x_{i}, y_{j})\) is the cost matrix. This optimization problem is known as a Linear Program.
Consider the transportation of \(x_{1}, x_{2}\), with weights \(a_{1}, a_{2}\) to \(y_{1}, y_{2}\) with weights \(b_{1}, b_{2}\). The Kantorovich problem reads as,
\[ \begin{eqnarray} & \underset{\gamma_{ij}}{\text{argmin}} &\text{ } C_{11}\gamma_{11} + C_{12}\gamma_{12} + C_{21}\gamma_{21} + C_{22}\gamma_{22}\\ & \text{subject to} & \gamma_{11} + \gamma_{12} = b_{1},\\ && \gamma_{21} + \gamma_{22} = b_{2},\\ && \gamma_{11} + \gamma_{21} = a_{1},\\ && \gamma_{12} + \gamma_{22} = a_{2} \end{eqnarray} \]Consider the transportation of \(x_{1}, x_{2}\), with weights \(a_{1}, a_{2}\) to \(y_{1}, y_{2}\) with weights \(b_{1}, b_{2}\). The Kantorovich problem reads as,
In this case \(c = [C_{11}, C_{12}, C_{13}, C_{14}]^{T}\), \(b = [b_{1}, b_{2}, a_{1}, a_{2}]\) and \(A\) is given by \[ \begin{bmatrix} 1 & 1 & 0 & 0\\ 0 & 0 & 1 & 1\\ 1 & 0 & 1 & 0\\ 0 & 1 & 0 & 1 \end{bmatrix} \] and finally, \(x = [\gamma_{11}, \gamma_{12}, \gamma_{21}, \gamma_{22}]\)
The Optimal Transportation problem, thus, becomes easily solvable through LP!
Existing approaches for solving LPs:
1. Dantzig's Simplex Algorithm [Dantzig, 1990]
2. Interior-Point Method or Karmakar Algorithm [Karmakar, 1984]
Going back to the colour transportation example, we may solve a LP for \(\gamma \in \mathbb{R}^{250\times 250}\) for getting the transport plan of a sub-set of 250 pixels of each image. Note that \(\gamma_{ij}\) represents the amount of mass transported from pixel \(i\) in the source image, to pixel \(j\) in the target image.
Even though we can solve a LP in theory, its cost is very prohibitive
Simplex Algorithm Complexity: Worst case \(O(2^{n})\), polynomial on average case.
Karmakar's Algorithm Complexity: Worst case \(O(n^{3.5})\)
Both algorithms do not scale for large number of samples
Solution to the scalability problem: introduce regularization
\[ \gamma^{*} = \underset{\gamma \in \Pi(\mu, \nu)}{\text{argmin}}\sum_{i}\sum_{j}C_{ij}\gamma_{ij} + \underset{\text{Entropy of }\gamma}{\lambda\sum_{i}\sum_{j}\gamma_{ij}(\log(\gamma_{ij})-1)} \]Note that we may rewrite this last problem as,
\[ \gamma^{*} = \underset{\gamma \in \Pi(\mu, \nu)}{\text{argmin}}\text{ }\text{KL}(\gamma|K) \]for \(K_{ij} = e^{-C_{ij}/\lambda}\) and \(KL(U|V)\),
\[ KL(U|V) = \sum_{i}\sum_{j}U_{ij}\log\biggr(\dfrac{U_{ij}}{V_{ij}}\biggr) - U_{ij} + V_{ij} \]The entrpic regularization allows us to find an approximate solution to the OT problem by using a much simpler algorithm: the Sinkhorn Algorithm [Cuturi, 2013]. The minimizer \(\gamma^{*}\) of \(KL(\gamma|K)\) is,
\[ \gamma^{*} = diag(u)K diag(v) \]for vectors \(u, v\) and \(K = e^{-C_{ij}/\lambda}\). But who are \(u\) and \(v\)?
Step 1. Write the Lagrangian of the regularized OT problem,
\[ \begin{align} \mathcal{L}(\gamma, \mathbf{f}, \mathbf{g}) = &\sum_{i}\sum_{j}\gamma_{ij}C_{ij} + \lambda\sum_{i}\sum_{j}\gamma_{ij}(\log(\gamma_{ij}) - 1) - \\&\sum_{i}f_{i}a_{i} - \sum_{j}g_{j}b_{j} \end{align} \] \[ \begin{align} \mathcal{L}(\gamma, \mathbf{f}, \mathbf{g}) = &\sum_{i}\sum_{j}\gamma_{ij}C_{ij} + \lambda\sum_{i}\sum_{j}\gamma_{ij}(\log(\gamma_{ij}) - 1) - \\&\sum_{i}f_{i}\sum_{k}\gamma_{ik} - \sum_{j}g_{j}\sum_{\ell}\gamma_{\ell j} \end{align} \]Step 2. Take the derivative with respect to \(\gamma_{ij}\)
\[ \dfrac{\partial \mathcal{L}}{\partial \gamma_{ij}} = C_{ij} + \lambda\log(\gamma_{ij}) - f_{i} - g_{j} \]Optimality implies that
\[ \gamma_{ij} = \underset{diag(u)}{e^{f_{i}/\lambda}}\underset{K}{e^{-C_{ij}/\lambda}}\underset{diag(v)}{e^{g_{j}/\lambda}} \]The structure \(\gamma^{*} = diag(u)K diag(v)\) allows us to employ a fast matrix-scaling algorithm [Sinkhorn, 1967]:
\[ \begin{align} u^{\ell+1} &= \dfrac{a}{Kv^{\ell}},\\ v^{\ell+1} &= \dfrac{b}{Ku^{\ell+1}}. \end{align} \]This algorithm has time complexity \(O(n^{2}\log(n)\tau^{-3})\), for \(\lambda = 4\log(n)/\tau\). Thus the Sinkhorn algorithm scales better with respect to \(n\), but one should be careful with the choice of \(\lambda\).
The impact of \(\lambda\) on \(\gamma\):
Note that using the Kantorovich formulation we may define a distance between probability measures,
\[ W_{p}(\mu, \nu)^{p} = \underset{\gamma \in \Pi(\mu, \nu)}{\text{minimize}}\text{ }\sum_{i=1}^{n}\sum_{j=1}^{m}||x_{i}-y_{j}||_{p}\gamma_{ij} \]Various results [Villani, 2008], [Peyre, 2019] show that this is a distance over the space of probability distributions.
Intuition: since an empirical measure \(\mu\) is uniquely defined in terms of its weights \(\{a_{i}\}_{i=1}^{n}\), and its support \(\{x_{i}\}_{i=1}^{n}\), one may understand \(W_{p}(\mu, \nu)\) in terms of the measures support and weights.
For this application we will compare the barycenter of 30 handwritten digits under different types of metrics.
We recall that the barycenter \(x^{*}\) of a set \(\{x_{i}\}_{i=1}^{N}\) of points in \(\mathbb{R}^{n}\) is defined as follows,
\[ x^{*} = \underset{x\in\mathbb{R}^{n}}{minimize}\dfrac{1}{N}\sum_{i=1}^{N}d(x, x_{i}) \]Metrics tried: 1. Euclidean Distance, 2. Wasserstein Distance
For the Euclidean distance, one has \(d(x, y) = ||x - y||^{2}\). The formula for the barycenter is derived as follows,
\[ \begin{align} \dfrac{\partial J}{\partial x} &= \dfrac{\partial}{\partial x}\biggr(\dfrac{1}{N}\sum_{i=1}^{N}(x-x_{i})^{T}(x-x_{i})\biggr),\\ &= \dfrac{1}{N}\sum_{i=1}^{N}\dfrac{\partial}{\partial x} (x^{T}x - 2x^{T}x_{i}+x_{i}^{T}x_{i}),\\ &= \dfrac{2}{N}\sum_{i=1}^{N}(x-x_{i}) \rightarrow x = \dfrac{1}{N}\sum_{i=1}^{N}x_{i} \end{align} \]For the Wasserstein distance, one has various probability measures \(\{\mu_{i}\}_{i=1}^{N}\)
\[ \mu^{*} = \underset{\mu}{\text{minimize}}\dfrac{1}{N}\sum_{i=1}^{N}W_{p}(\mu, \mu_{i}) \]Notice: the Wasserstein Barycenter is a probability measure, rather than a point \(x^{*}\)
Conceptual shift: Previously we have modeled the barycenter of poitns \(\{x_{i}\}_{i=1}^{N}\). Since the measures are empirical, one has \(\mu_{i} = \sum_{j=1}^{n_{i}}\delta(x - x_{ij})\). The points \(\{x_{ij}\}_{j=1}^{n_{i}}\) are called the support of \(\mu_{i}\).
Nevertheless we want a vector \(x^{*} \in \mathbb{R}^{784}\). How to bridge the gap between measures and the support?
Note: by changing the support, one changes the probability measure. Thus the Wasserstein barycenter can be optimized in terms of the points \(x_{ij}\). This is called Free Support Barycenter [Cuturi, 2014]
When building a classification system, one supposes that training and test data come from the same probability distribution, this assumption, however, is not verified in practice
Domain adaptation (DA) is a sub-set of transfer learning. Its goal is to help learning a classifier on a target domain (e.g. house street numbers) from a source domain (e.g. handwritten digits).
Assumptions:
1. Target domain samples, \(\{x_{t}^{j}\}_{j=1}^{n_{t}}\) are not labeled (unsupervised DA)
2. Covariate shift hypothesis: In general, one assumes that \(P_{s}(X) \neq P_{t}(X)\) but \(P_{s}(Y|X) = P_{t}(Y|X)\).
[Courty, 2016] proposed to use Optimal Transport to match source and target probability distributions
The proposed framework is known as Optimal Transport for Domain Adaptation (OTDA)
To illustrate the OTDA framework, let us consider two sets of handwritten digits of shape \(16 \times 16\),
Baseline Accuracy using a linear SVM: 36.34%
OTDA Methodology:
1. From data poitns \(X_{s} = \{x_{s}^{i}\}_{i=1}^{n_{s}}\) and \(X_{t} = \{x_{t}^{j}\}_{j=1}^{n_{t}}\) let \(\mu_{s} = \sum_{i=1}^{n_{s}}\delta(x - x_{s}^{i})\) and \(\mu_{t} = \sum_{j=1}^{n_{t}}\delta(x - x_{t}^{j})\)
2. Estimate \(\gamma\) either through LP, or through Sinkhorn's Algorithm
3. Calculate the Barycenter Mapping [Courty, 2016]:
\[ \hat{X}_{s} = n_{t}\gamma X_{t} \]4. Fit data on \((\hat{X}_{s}, y_{s})\). Evaluate on \((X_{t}, y_{t})\).
Applying the aforementioned methodology, one gets,
After transporting the source samples, the accuracy improves to 45.68%.
In this lecture we have explified many problems in Machine Learning that can profit from the theory of Optimal Transport
These involve (but are by no means limited to):
1. Unsupervised Learning, with barycenter calculation
2. Supervised Learning, especially transfer learning
Due the introductory approach of this lecture, many algorithms were left out.
Other topics may me interesting:
1. Generative Modeling through the Wasserstein Distance
Generative Adversarial Networks (GANs) [Goodfellow, 2014], especially Wasserstein GANs (WGANs) [Arjovsky, 2017]
Deep Wasserstein Embeddings (DWEs) [Courty, 2017]
2. OT on structured data [Flamary, 2019]
OT on graphs [Vayer, 2018]
A good place for start learning about OT is the book by [Peyré, 2019].
The book takes a computational approach to OT, which is similar to this presentation (the reasoning presented here was inpired on this book).
Since OT is per se a mathematical field, far more advanced (with respect to mathematical formality) books are available. The standard book for a mathematical approach to OT is [Villani, 2008]
Both books are freely available on the web.
There are toolboxes for the most used statistical/machine learning programming languages
Python Optimal Transport by [Flamary, 2017]
OptimalTransport.jil (Julia)
"transport" package for R
[Dantzig, 1990] Dantzig, George B. "Origins of the simplex method." A history of scientific computing. 1990. 141-151.
[Karmakar, 1984] Karmarkar, Narendra. "A new polynomial-time algorithm for linear programming." Proceedings of the sixteenth annual ACM symposium on Theory of computing. 1984.
[Cuturi, 2013] Cuturi, Marco. "Sinkhorn distances: lightspeed computation of optimal transport." NIPS. Vol. 2. No. 3. 2013.
[Sinkhorn, 1967] Sinkhorn, Richard, and Paul Knopp. "Concerning nonnegative matrices and doubly stochastic matrices." Pacific Journal of Mathematics 21.2 (1967): 343-348.
[Cuturi, 2014] Cuturi, Marco, and Arnaud Doucet. "Fast computation of Wasserstein barycenters." International conference on machine learning. PMLR, 2014.
[Villani, 2008] Villani, Cédric. Optimal transport: old and new. Vol. 338. Springer Science & Business Media, 2008.
[Peyré, 2019] Peyré, Gabriel, and Marco Cuturi. "Computational optimal transport: With applications to data science." Foundations and Trends® in Machine Learning 11.5-6 (2019): 355-607.
[Courty, 2016] Courty, Nicolas, et al. "Optimal transport for domain adaptation." IEEE transactions on pattern analysis and machine intelligence 39.9 (2016): 1853-1865.
[Goodfellow, 2014] Goodfellow, Ian J., et al. "Generative adversarial networks." arXiv preprint arXiv:1406.2661 (2014).
[Arjovsky, 2017] Arjovsky, Martin, Soumith Chintala, and Léon Bottou. "Wasserstein generative adversarial networks." International conference on machine learning. PMLR, 2017.
[Courty, 2017] Courty, Nicolas, Rémi Flamary, and Mélanie Ducoffe. "Learning wasserstein embeddings." arXiv preprint arXiv:1710.07457 (2017).
[Flamary, 2019] FLAMARY, Rémi. Transport optimal pour l’apprentissage statistique. Diss. Télécom Paristech, 2019.
[Vayer, 2018] Vayer, Titouan, et al. "Optimal Transport for structured data with application on graphs." arXiv preprint arXiv:1805.09114 (2018).
[Flamary, 2017] Flamary, Rémi, and Nicolas Courty. "Pot python optimal transport library." GitHub: https://github. com/rflamary/POT (2017): 144.


Hide when guests come over instantly break out into full speed make cat go crazy. Meow mix meow meow cat things and purring. catnip.
Hide when guests come over instantly break out into full speed make cat go crazy. Meow mix meow meow cat things and purring. catnip.
Hide when guests come over instantly break out into full speed make cat go crazy. Meow mix meow meow cat things and purring. catnip.
Hide when guests come over instantly break out into full speed make cat go crazy. Meow mix meow meow cat things and purring. catnip.


version 1.1.3
Text2Vector
A simple HTML file that uses JavaScript to generate an SVG of the text you type into the textarea.
Workspace
Copy SVG To Clipboard
Download SVG
Text Controls
Font
Text Alignment
Left
Center
Right
Font Size
Tracking
Line Spacing
Italic
Angle
Monospaced
Apply Kerning
Edit Kerning
Scale View
Edit Kerning Instructions:
Place your cursor between two characters.
[F1] Decrease character spacing by 10%
[F2] Increase character spacing by 10%
[F3] Decrease character spacing by 1%
[F4] Increase character spacing by 1%
[F5] Save changes to "{font name}.data" file (be sure to replace the existing file with this new one)


NZ's Ferguson misses out on test debut against England
by ReutersNew Zealand fast bowler Lockie Ferguson has missed out on making his long-awaited test debut against England in the first game of the two-match series at Mt. Maunganui on Thursday.
Captain Kane Williamson told reporters at Bay Oval on Wednesday that they had decided to stick with the tried and tested pace trio of Tim Southee, Trent Boult and Neil Wagner, with Mitchell Santner named as the solitary spinner.
New Zealand: Tom Latham, Jeet Raval, Kane Williamson (captain), Ross Taylor, Henry Nicholls, BJ Watling, Colin de Grandhomme, Mitchell Santner, Tim Southee, Neil Wagner, Trent Boult.


If more than one label applies to the image, select multiple labels.
If no labels apply, select None of the above
Read the task carefully and inspect the image.
Choose the appropriate label(s) that best suit the image.


[gecode-users] independent subproblems
Malcolm Ryan
malcolmr at cse.unsw.edu.au
Tue Apr 8 02:45:11 CEST 2008
At a certain stage in my search the problem can be split into several
independent sub-problems. If I try to solve them sequentially, then a
failure in one of the later ones will cause fruitless backtracking in
the earlier ones (when it really needs to jump all the way back to the
first phase of the search). Does Gecode provide any kind of mechanism
for handling this situation?
Thanks,
Malcolm
More information about the gecode-users
mailing list


Please select topping
Cheese Pizza
Your favorite cheese pizza made with classic marinara sauce topped with mozzarella cheese.
Order pizza online now.
Cheese
Pepperoni Pizza
This gourmet pizza is ideal for easy late night delivery, complete with mozzarella cheese and pepperoni.
Order pizza online now.
Pepperoni
Meat Pizza
Meat lover's pizza is the perfect game day pizza, packed with pepperoni, Italian sausage, ham, bacon, seasoned pork and beef. Order pizza online now.
Meat
Combination Pizza
Enjoy this freshly prepared pizza for family dinner or a group lunch, including pepperoni, seasoned pork, beef, mushrooms, green bell peppers and red onions. Order pizza online now.
Combination
Please select size
XLarge
Large
Medium
Small


Seems your browser doesn't support Javascript! Websocket relies on Javascript being enabled. Please enable Javascript and reload this page!
Your client id:
connect to service
disconnect service
Type your message and click to send:
Send
-------------------------------------------------------------


Contact Us
You can contact us, no matter whether You would like to ask us something, give an idea for some event or just share Your ideas in order to prove our quality, we would be happy to hear it!
-
Words Company
123 Ukraina Str
Sofia, Bulgaria - + 359 (Phone) 123456
- +359 (FAX) 0011223
- wordsinthecity@gmail.com


Black students have a 17% chance of being suspended. Suppose two separate Black students get called to the principal's office. Let’s explore the probability of both students receiving the same outcome, meaning either both students get suspended or neither student gets suspended. We will assume that the students’ visits to the principal are for separate offenses. What is the probability that both students are suspended?
in-context


@(settings:FacebookSettings, charity:PartyCharity, heartAvatarUrl:String, firstname:String, noOfVotes:Int, donation:Int)


Machine learning is the science of giving computers the ability to learn without being explicitly programmed. The idea is that there exist generic algorithms which can be used to find patterns in a broad class of data sets without having to write code specifically for each problem. The algorithm will build its own logic based on the data.
Machine learning is a subfield of computer science, and is closely related to computational statistics. It evolved from the study of pattern recognition in artificial intelligence (AI) research, and has made contributions to AI tasks like computer vision, natural language processing and speech recognition. It has also, especially in later years, found applications in a wide variety of other areas, including bioinformatics, economy, physics, finance and marketing.
The approaches to machine learning are many, but are often split into two main categories. In supervised learning we know the answer to a problem, and let the computer deduce the logic behind it. On the other hand, unsupervised learning is a method for finding patterns and relationship in data sets without any prior knowledge of the system. Some authours also operate with a third category, namely reinforcement learning. This is a paradigm of learning inspired by behavioural psychology, where learning is achieved by trial-and-error, solely from rewards and punishment.
Another way to categorize machine learning tasks is to consider the desired output of a system. Some of the most common tasks are:
The field of artificial neural networks has a long history of development, and is closely connected with the advancement of computer science and computers in general. A model of artificial neurons was first developed by McCulloch and Pitts in 1943 to study signal processing in the brain and has later been refined by others. The general idea is to mimic neural networks in the human brain, which is composed of billions of neurons that communicate with each other by sending electrical signals. Each neuron accumulates its incoming signals, which must exceed an activation threshold to yield an output. If the threshold is not overcome, the neuron remains inactive, i.e. has zero output.
This behaviour has inspired a simple mathematical model for an artificial neuron. $$ \begin{equation} y = f\left(\sum_{i=1}^n w_ix_i\right) = f(u) \label{artificialNeuron} \end{equation} $$ Here, the output \( y \) of the neuron is the value of its activation function, which have as input a weighted sum of signals \( x_i, \dots ,x_n \) received by \( n \) other neurons.
Conceptually, it is helpful to divide neural networks into four categories:
In quantum information theory, it has been shown that one can perform gate decompositions with the help of neural. In lattice quantum chromodynamics, DNNs have been used to learn action parameters in regions of parameter space where PCA fails. Last but not least, DNNs also found place in the study of quantum, and in scattering theory to learn \( s \)-wave scattering length of potentials.
An artificial neural network (NN), is a computational model that consists of layers of connected neurons, or nodes. It is supposed to mimic a biological nervous system by letting each neuron interact with other neurons by sending signals in the form of mathematical functions between layers. A wide variety of different NNs have been developed, but most of them consist of an input layer, an output layer and eventual layers in-between, called hidden layers. All layers can contain an arbitrary number of nodes, and each connection between two nodes is associated with a weight variable.
Neural networks (also called neural nets) are neural-inspired nonlinear models for supervised learning. As we will see, neural nets can be viewed as natural, more powerful extensions of supervised learning methods such as linear and logistic regression and soft-max methods.
The feed-forward neural network (FFNN) was the first and simplest type of NN devised. In this network, the information moves in only one direction: forward through the layers.
Nodes are represented by circles, while the arrows display the connections between the nodes, including the direction of information flow. Additionally, each arrow corresponds to a weight variable, not displayed here. We observe that each node in a layer is connected to all nodes in the subsequent layer, making this a so-called fully-connected FFNN.
A different variant of FFNNs are convolutional neural networks (CNNs), which have a connectivity pattern inspired by the animal visual cortex. Individual neurons in the visual cortex only respond to stimuli from small sub-regions of the visual field, called a receptive field. This makes the neurons well-suited to exploit the strong spatially local correlation present in natural images. The response of each neuron can be approximated mathematically as a convolution operation.
CNNs emulate the behaviour of neurons in the visual cortex by enforcing a local connectivity pattern between nodes of adjacent layers: Each node in a convolutional layer is connected only to a subset of the nodes in the previous layer, in contrast to the fully-connected FFNN. Often, CNNs consist of several convolutional layers that learn local features of the input, with a fully-connected layer at the end, which gathers all the local data and produces the outputs. They have wide applications in image and video recognition
So far we have only mentioned NNs where information flows in one direction: forward. Recurrent neural networks on the other hand, have connections between nodes that form directed cycles. This creates a form of internal memory which are able to capture information on what has been calculated before; the output is dependent on the previous computations. Recurrent NNs make use of sequential information by performing the same task for every element in a sequence, where each element depends on previous elements. An example of such information is sentences, making recurrent NNs especially well-suited for handwriting and speech recognition.
There are many other kinds of NNs that have been developed. One type that is specifically designed for interpolation in multidimensional space is the radial basis function (RBF) network. RBFs are typically made up of three layers: an input layer, a hidden layer with non-linear radial symmetric activation functions and a linear output layer (''linear'' here means that each node in the output layer has a linear activation function). The layers are normally fully-connected and there are no cycles, thus RBFs can be viewed as a type of fully-connected FFNN. They are however usually treated as a separate type of NN due the unusual activation functions.
Other types of NNs could also be mentioned, but are outside the scope of this work. We will now move on to a detailed description of how a fully-connected FFNN works, and how it can be used to interpolate data sets.
One use often so-called fully-connected feed-forward neural networks with three or more layers (an input layer, one or more hidden layers and an output layer) consisting of neurons that have non-linear activation functions.
Such networks are often called multilayer perceptrons (MLPs)
According to the Universal approximation theorem, a feed-forward neural network with just a single hidden layer containing a finite number of neurons can approximate a continuous multidimensional function to arbitrary accuracy, assuming the activation function for the hidden layer is a non-constant, bounded and monotonically-increasing continuous function. Note that the requirements on the activation function only applies to the hidden layer, the output nodes are always assumed to be linear, so as to not restrict the range of output values.
We note that this theorem is only applicable to a NN with one hidden layer. Therefore, we can easily construct an NN that employs activation functions which do not satisfy the above requirements, as long as we have at least one layer with activation functions that do. Furthermore, although the universal approximation theorem lays the theoretical foundation for regression with neural networks, it does not say anything about how things work in practice: A neural network can still be able to approximate a given function reasonably well without having the flexibility to fit all other functions.
First, for each node \( i \) in the first hidden layer, we calculate a weighted sum \( u_i^1 \) of the input coordinates \( x_j \), $$ \begin{equation} u_i^1 = \sum_{j=1}^2 w_{ij}^1 x_j + b_i^1 \label{_auto1} \end{equation} $$ This value is the argument to the activation function \( f_1 \) of each neuron \( i \), producing the output \( y_i^1 \) of all neurons in layer 1, $$ \begin{equation} y_i^1 = f_1(u_i^1) = f_1\left(\sum_{j=1}^2 w_{ij}^1 x_j + b_i^1\right) \label{outputLayer1} \end{equation} $$ where we assume that all nodes in the same layer have identical activation functions, hence the notation \( f_l \) $$ \begin{equation} y_i^l = f_l(u_i^l) = f_l\left(\sum_{j=1}^{N_{l-1}} w_{ij}^l y_j^{l-1} + b_i^l\right) \label{generalLayer} \end{equation} $$ where \( N_l \) is the number of nodes in layer \( l \). When the output of all the nodes in the first hidden layer are computed, the values of the subsequent layer can be calculated and so forth until the output is obtained.
The output of neuron \( i \) in layer 2 is thus, $$ \begin{align} y_i^2 &= f_2\left(\sum_{j=1}^3 w_{ij}^2 y_j^1 + b_i^2\right) \label{_auto2}\\ &= f_2\left[\sum_{j=1}^3 w_{ij}^2f_1\left(\sum_{k=1}^2 w_{jk}^1 x_k + b_j^1\right) + b_i^2\right] \label{outputLayer2} \end{align} $$ where we have substituted \( y_m^1 \) with.  The complete functional form is, $$ \begin{align} &y^{l+1}_1\! = \!f_{l+1}\!\left[\!\sum_{j=1}^{N_l}\! w_{1j}^3 f_l\!\left(\!\sum_{k=1}^{N_{l-1}}\! w_{jk}^2 f_{l-1}\!\left(\! \dots \!f_1\!\left(\!\sum_{n=1}^{N_0} \!w_{mn}^1 x_n\! + \!b_m^1\!\right) \!\dots \!\right) \!+ \!b_k^2\!\right) \!+ \!b_1^3\!\right] && \label{completeNN} \end{align} $$ which illustrates a basic property of MLPs: The only independent variables are the input values \( x_n \).
This confirms that an MLP, despite its quite convoluted mathematical form, is nothing more than an analytic function, specifically a mapping of real-valued vectors \( \vec{x} \in \mathbb{R}^n \rightarrow \vec{y} \in \mathbb{R}^m \). In our example, \( n=2 \) and \( m=1 \). Consequentially, the number of input and output values of the function we want to fit must be equal to the number of inputs and outputs of our MLP.
Furthermore, the flexibility and universality of a MLP can be illustrated by realizing that the expression is essentially a nested sum of scaled activation functions of the form $$ \begin{equation} h(x) = c_1 f(c_2 x + c_3) + c_4 \label{_auto5} \end{equation} $$ where the parameters \( c_i \) are weights and biases. By adjusting these parameters, the activation functions can be shifted up and down or left and right, change slope or be rescaled which is the key to the flexibility of a neural network.
Additionally, we can represent the biases and activations as layer-wise column vectors \( \vec{b}_l \) and \( \vec{y}_l \), so that the \( i \)-th element of each vector is the bias \( b_i^l \) and activation \( y_i^l \) of node \( i \) in layer \( l \) respectively.
We have that \( \mathrm{W}_l \) is a \( N_{l-1} \times N_l \) matrix, while \( \vec{b}_l \) and \( \vec{y}_l \) are \( N_l \times 1 \) column vectors. With this notation, the sum in becomes a matrix-vector multiplication, and we can write the equation for the activations of hidden layer 2 in $$ \begin{equation} \vec{y}_2 = f_2(\mathrm{W}_2 \vec{y}_{1} + \vec{b}_{2}) = f_2\left(\left[\begin{array}{ccc} w^2_{11} &w^2_{12} &w^2_{13} \\ w^2_{21} &w^2_{22} &w^2_{23} \\ w^2_{31} &w^2_{32} &w^2_{33} \\ \end{array} \right] \cdot \left[\begin{array}{c} y^1_1 \\ y^1_2 \\ y^1_3 \\ \end{array}\right] + \left[\begin{array}{c} b^2_1 \\ b^2_2 \\ b^2_3 \\ \end{array}\right]\right). \label{_auto6} \end{equation} $$
A property that characterizes a neural network, other than its connectivity, is the choice of activation function(s). As described in, the following restrictions are imposed on an activation function for a FFNN to fulfill the universal approximation theorem
The second requirement excludes all linear functions. Furthermore, in a MLP with only linear activation functions, each layer simply performs a linear transformation of its inputs.
Regardless of the number of layers, the output of the NN will be nothing but a linear function of the inputs. Thus we need to introduce some kind of non-linearity to the NN to be able to fit non-linear functions Typical examples are the logistic Sigmoid $$ \begin{equation} f(x) = \frac{1}{1 + e^{-x}}, \label{sigmoidActivationFunction} \end{equation} $$ and the hyperbolic tangent function $$ \begin{equation} f(x) = \tanh(x) \label{tanhActivationFunction} \end{equation} $$
"""The sigmoid function (or the logistic curve) is a
function that takes any real number, z, and outputs a number (0,1).
It is useful in neural networks for assigning weights on a relative scale.
The value z is the weighted sum of parameters involved in the learning algorithm."""
import numpy
import matplotlib.pyplot as plt
import math as mt
z = numpy.arange(-5, 5, .1)
sigma_fn = numpy.vectorize(lambda z: 1/(1+numpy.exp(-z)))
sigma = sigma_fn(z)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(z, sigma)
ax.set_ylim([-0.1, 1.1])
ax.set_xlim([-5,5])
ax.grid(True)
ax.set_xlabel('z')
ax.set_title('sigmoid function')
plt.show()
"""Step Function"""
z = numpy.arange(-5, 5, .02)
step_fn = numpy.vectorize(lambda z: 1.0 if z >= 0.0 else 0.0)
step = step_fn(z)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(z, step)
ax.set_ylim([-0.5, 1.5])
ax.set_xlim([-5,5])
ax.grid(True)
ax.set_xlabel('z')
ax.set_title('step function')
plt.show()
"""Sine Function"""
z = numpy.arange(-2*mt.pi, 2*mt.pi, 0.1)
t = numpy.sin(z)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(z, t)
ax.set_ylim([-1.0, 1.0])
ax.set_xlim([-2*mt.pi,2*mt.pi])
ax.grid(True)
ax.set_xlabel('z')
ax.set_title('sine function')
plt.show()
"""Plots a graph of the squashing function used by a rectified linear
unit"""
z = numpy.arange(-2, 2, .1)
zero = numpy.zeros(len(z))
y = numpy.max([zero, z], axis=0)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(z, y)
ax.set_ylim([-2.0, 2.0])
ax.set_xlim([-2.0, 2.0])
ax.grid(True)
ax.set_xlabel('z')
ax.set_title('Rectified linear unit')
plt.show()
from scipy import optimize
class Neural_Network(object):
def __init__(self, Lambda=0):
#Define Hyperparameters
self.inputLayerSize = 2
self.outputLayerSize = 1
self.hiddenLayerSize = 3
#Weights (parameters)
self.W1 = np.random.randn(self.inputLayerSize,self.hiddenLayerSize)
self.W2 = np.random.randn(self.hiddenLayerSize,self.outputLayerSize)
#Regularization Parameter:
self.Lambda = Lambda
def forward(self, X):
#Propogate inputs though network
self.z2 = np.dot(X, self.W1)
self.a2 = self.sigmoid(self.z2)
self.z3 = np.dot(self.a2, self.W2)
yHat = self.sigmoid(self.z3)
return yHat
def sigmoid(self, z):
#Apply sigmoid activation function to scalar, vector, or matrix
return 1/(1+np.exp(-z))
def sigmoidPrime(self,z):
#Gradient of sigmoid
return np.exp(-z)/((1+np.exp(-z))**2)
def costFunction(self, X, y):
#Compute cost for given X,y, use weights already stored in class.
self.yHat = self.forward(X)
J = 0.5*sum((y-self.yHat)**2)/X.shape[0] + (self.Lambda/2)*(np.sum(self.W1**2)+np.sum(self.W2**2))
return J
def costFunctionPrime(self, X, y):
#Compute derivative with respect to W and W2 for a given X and y:
self.yHat = self.forward(X)
delta3 = np.multiply(-(y-self.yHat), self.sigmoidPrime(self.z3))
#Add gradient of regularization term:
dJdW2 = np.dot(self.a2.T, delta3)/X.shape[0] + self.Lambda*self.W2
delta2 = np.dot(delta3, self.W2.T)*self.sigmoidPrime(self.z2)
#Add gradient of regularization term:
dJdW1 = np.dot(X.T, delta2)/X.shape[0] + self.Lambda*self.W1
return dJdW1, dJdW2
#Helper functions for interacting with other methods/classes
def getParams(self):
#Get W1 and W2 Rolled into vector:
params = np.concatenate((self.W1.ravel(), self.W2.ravel()))
return params
def setParams(self, params):
#Set W1 and W2 using single parameter vector:
W1_start = 0
W1_end = self.hiddenLayerSize*self.inputLayerSize
self.W1 = np.reshape(params[W1_start:W1_end], \
(self.inputLayerSize, self.hiddenLayerSize))
W2_end = W1_end + self.hiddenLayerSize*self.outputLayerSize
self.W2 = np.reshape(params[W1_end:W2_end], \
(self.hiddenLayerSize, self.outputLayerSize))
def computeGradients(self, X, y):
dJdW1, dJdW2 = self.costFunctionPrime(X, y)
return np.concatenate((dJdW1.ravel(), dJdW2.ravel()))
class trainer(object):
def __init__(self, N):
#Make Local reference to network:
self.N = N
def callbackF(self, params):
self.N.setParams(params)
self.J.append(self.N.costFunction(self.X, self.y))
self.testJ.append(self.N.costFunction(self.testX, self.testY))
def costFunctionWrapper(self, params, X, y):
self.N.setParams(params)
cost = self.N.costFunction(X, y)
grad = self.N.computeGradients(X,y)
return cost, grad
def train(self, trainX, trainY, testX, testY):
#Make an internal variable for the callback function:
self.X = trainX
self.y = trainY
self.testX = testX
self.testY = testY
#Make empty list to store training costs:
self.J = []
self.testJ = []
params0 = self.N.getParams()
options = {'maxiter': 200, 'disp' : True}
_res = optimize.minimize(self.costFunctionWrapper, params0, jac=True, method='BFGS', \
args=(trainX, trainY), options=options, callback=self.callbackF)
self.N.setParams(_res.x)
self.optimizationResults = _res
import numpy as np
#sigmoid
def nonlin(x, deriv=False):
if (deriv==True):
return x*(1-x)
return 1/(1+np.exp(-x))
#input data
x=np.array([[0,0,1],[0,1,1],[1,0,1],[1,1,1]])
#output data
y=np.array([0,1,1,0]).T
#seed random numbers to make calculation
np.random.seed(1)
#initialize weights with mean=0
syn0=2*np.random.random((3,4))-1
for iter in range(10000):
#forward propogation
l0=x
l1=nonlin(np.dot(l0,syn0))
l1_error=y-l1
#multiply error by slope of sigmoid at values of l1
l1_delta=l1_error*nonlin(l1,True)
#update weights
syn0+=np.dot(l0.T, l1_delta)
print("Output after training: ",l1 )
import numpy as np
import random
class Network(object):
def _init_(self, sizes):
self.num_layers=len(sizes)
self.sizes=sizes
self.biases=[np.random.randn(y,1) for y in sizes[1:]]
self.weights=[np.random.randn(y,x) for x,y in zip(sizes[:-1], sizes[1:])]
#sizes is the number of neurons in each layer
#for example, say n_1st_layer=3, n_2nd_layer=3, n_3rd_layer=1, then net=Network([3,3,1])
#The biases and weights are initialized randomly, using Gaussian distributions of mean=0, stdev=1
#z is a vector (or a np.array)
def feedforward(self,a):
#returns output w/ 'a' as an input
for b, w in zip(self.biases, self.weights):
a=sigmoid(np.dot(w,b)+b)
return a
#Apply a Stochastic Gradient Descent (SGD) method:
def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):
"""Trains network using batches incorporating SGD. The network will be evaluated against the
test data after each epoch, with partial progress being printed out (this is useful for tracking,
but slows the process.)"""
if test_data: n_test=len(test_data)
n=len(training_data)
for j in xrange(epochs):
random.shuffle(training_data)
mini_batches=[training_data[k:k+mini_batch_size] for k in xrange(o,n,mini_batch_size)]
for mini_batch in mini_batches:
self.update_mini_batch(mini_batch, eta)
if test_data:
print ("Epoch {0}: {1}/{2}".format(j, self.evaluate(test_data), n_test))
else:
print ("Epoch {0} complete".format(j))
def update_mini_batch(self, mini_batch, eta):
#updates w and b using backpropagation to a single mini batch. eta is the learning rate."
nabla_b=[np.zeros(b.shape) for b in self.biases]
nabla_w=[np.zeros(w.shape) for w in self.weights]
for x,y in mini_batch:
delta_nabla_b, delta_nabla_w=self.backprop(x,y)
nabla_b=[nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
nabla_w=[nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
self.weights=[w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]
self.biases=[b-(eta/len(mini_batch))*nb for b, nb in zip(self.biases, nabla_b)]
def backprop(self, x, y):
"""Return a tuple ``(nabla_b, nabla_w)`` representing the
gradient for the cost function C_x. ``nabla_b`` and
``nabla_w`` are layer-by-layer lists of numpy arrays, similar
to ``self.biases`` and ``self.weights``."""
nabla_b = [np.zeros(b.shape) for b in self.biases]
nabla_w = [np.zeros(w.shape) for w in self.weights]
# feedforward
activation = x
activations = [x] # list to store all the activations, layer by layer
zs = [] # list to store all the z vectors, layer by layer
for b, w in zip(self.biases, self.weights):
z = np.dot(w, activation)+b
zs.append(z)
activation = sigmoid(z)
activations.append(activation)
# backward pass
delta = self.cost_derivative(activations[-1], y) * \
sigmoid_prime(zs[-1])
nabla_b[-1] = delta
nabla_w[-1] = np.dot(delta, activations[-2].transpose())
# Note that the variable l in the loop below is used a little
# differently to the notation in Chapter 2 of the book. Here,
# l = 1 means the last layer of neurons, l = 2 is the
# second-last layer, and so on. It's a renumbering of the
# scheme in the book, used here to take advantage of the fact
# that Python can use negative indices in lists.
for l in xrange(2, self.num_layers):
z = zs[-l]
sp = sigmoid_prime(z)
delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
nabla_b[-l] = delta
nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
return (nabla_b, nabla_w)
def evaluate(self, test_data):
"""Return the number of test inputs for which the neural
network outputs the correct result. Note that the neural
network's output is assumed to be the index of whichever
neuron in the final layer has the highest activation."""
test_results = [(np.argmax(self.feedforward(x)), y)
for (x, y) in test_data]
return sum(int(x == y) for (x, y) in test_results)
def cost_derivative(self, output_activations, y):
"""Return the vector of partial derivatives \partial C_x /
\partial a for the output activations."""
return (output_activations-y)
#Functions
def sigmoid(z):
return 1.0/(1.0+np.exp(-z))
def sigmoid_prime(z):
return sigmoid(z)*(1-sigmoid(z))
network=Network()
# %load neural-networks-and-deep-learning/src/mnist_loader.py
"""
mnist_loader
~~~~~~~~~~~~
A library to load the MNIST image data. For details of the data
structures that are returned, see the doc strings for ``load_data``
and ``load_data_wrapper``. In practice, ``load_data_wrapper`` is the
function usually called by our neural network code.
"""
#### Libraries
# Standard library
import pickle
import gzip
# Third-party libraries
import numpy as np
def load_data():
"""Return the MNIST data as a tuple containing the training data,
the validation data, and the test data.
The ``training_data`` is returned as a tuple with two entries.
The first entry contains the actual training images. This is a
numpy ndarray with 50,000 entries. Each entry is, in turn, a
numpy ndarray with 784 values, representing the 28 * 28 = 784
pixels in a single MNIST image.
The second entry in the ``training_data`` tuple is a numpy ndarray
containing 50,000 entries. Those entries are just the digit
values (0...9) for the corresponding images contained in the first
entry of the tuple.
The ``validation_data`` and ``test_data`` are similar, except
each contains only 10,000 images.
This is a nice data format, but for use in neural networks it's
helpful to modify the format of the ``training_data`` a little.
That's done in the wrapper function ``load_data_wrapper()``, see
below.
"""
f = gzip.open('../data/mnist.pkl.gz', 'rb')
training_data, validation_data, test_data = cPickle.load(f)
f.close()
return (training_data, validation_data, test_data)
def load_data_wrapper():
"""Return a tuple containing ``(training_data, validation_data,
test_data)``. Based on ``load_data``, but the format is more
convenient for use in our implementation of neural networks.
In particular, ``training_data`` is a list containing 50,000
2-tuples ``(x, y)``. ``x`` is a 784-dimensional numpy.ndarray
containing the input image. ``y`` is a 10-dimensional
numpy.ndarray representing the unit vector corresponding to the
correct digit for ``x``.
``validation_data`` and ``test_data`` are lists containing 10,000
2-tuples ``(x, y)``. In each case, ``x`` is a 784-dimensional
numpy.ndarry containing the input image, and ``y`` is the
corresponding classification, i.e., the digit values (integers)
corresponding to ``x``.
Obviously, this means we're using slightly different formats for
the training data and the validation / test data. These formats
turn out to be the most convenient for use in our neural network
code."""
tr_d, va_d, te_d = load_data()
training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
training_results = [vectorized_result(y) for y in tr_d[1]]
training_data = zip(training_inputs, training_results)
validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
validation_data = zip(validation_inputs, va_d[1])
test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
test_data = zip(test_inputs, te_d[1])
return (training_data, validation_data, test_data)
def vectorized_result(j):
"""Return a 10-dimensional unit vector with a 1.0 in the jth
position and zeroes elsewhere. This is used to convert a digit
(0...9) into a corresponding desired output from the neural
network."""
e = np.zeros((10, 1))
e[j] = 1.0
return e
net=network.Network([784,30,30])
net.SGD(training_data,30,10,3,test_data=test_data)


| 1 | package fr.sii.ogham.email.sendgrid.v4.sender.impl.sendgrid.handler; | |
| 2 | ||
| 3 | import org.slf4j.Logger; | |
| 4 | import org.slf4j.LoggerFactory; | |
| 5 | ||
| 6 | import fr.sii.ogham.core.message.content.Content; | |
| 7 | import fr.sii.ogham.email.attachment.Attachment; | |
| 8 | import fr.sii.ogham.email.exception.handler.ContentHandlerException; | |
| 9 | import fr.sii.ogham.email.message.Email; | |
| 10 | import fr.sii.ogham.email.message.content.ContentWithAttachments; | |
| 11 | import fr.sii.ogham.email.sendgrid.v4.sender.impl.sendgrid.compat.MailCompat; | |
| 12 | ||
| 13 | /** | |
| 14 | * Content handler that extract {@link Attachment} that are associated to the | |
| 15 | * {@link ContentWithAttachments}. | |
| 16 | */ | |
| 17 | public final class ContentWithAttachmentsHandler implements SendGridContentHandler { | |
| 18 | private static final Logger LOG = LoggerFactory.getLogger(ContentWithAttachmentsHandler.class); | |
| 19 | private final SendGridContentHandler delegate; | |
| 20 | ||
| 21 | /** | |
| 22 | * Initialize with the {@link SendGridContentHandler} that is able to handle | |
| 23 | * the underlying content. | |
| 24 | * | |
| 25 | * @param delegate | |
| 26 | * the handler | |
| 27 | */ | |
| 28 | public ContentWithAttachmentsHandler(SendGridContentHandler delegate) { | |
| 29 | super(); | |
| 30 | this.delegate = delegate; | |
| 31 | } | |
| 32 | ||
| 33 | @Override | |
| 34 | public void setContent(Email original, MailCompat email, Content content) throws ContentHandlerException { | |
| 35 | ContentWithAttachments cwa = (ContentWithAttachments) content; | |
| 36 | for (Attachment attachment : cwa.getAttachments()) { | |
| 37 | LOG.debug("Attaching {} to email", attachment); | |
| 38 | original.attach(attachment); | |
| 39 | } | |
| 40 |
1
1. setContent : removed call to fr/sii/ogham/email/sendgrid/v4/sender/impl/sendgrid/handler/SendGridContentHandler::setContent → NO_COVERAGE |
delegate.setContent(original, email, cwa.getContent()); |
| 41 | } | |
| 42 | } | |
Mutations | ||
| 40 |
1.1 |


Title and author:
Ondas transversal e logitudinal
Humberto Carmona
© 2021, Humberto Carmona. Compiled with EJS 6.01 (201013)
Released under a
license.


Components Selection
Graduate Project of Component-based Distributed Social Network Text Mining System
Data Collection
Real-time Tweets
Timeline of User
Query by Text
Favorite List
Data Processing
Sentiment Analyze
Trends
Word Count
TFIDF
Add Component
Data Visualization
Map
Bar Chart
Pie Chart
Word Cloud
Submit Topology