EASTER 3 TUESDAY
Entrance Antiphon
Sing praise to our God, all you who fear God, both small and great, for now salvation and strength have come, and the power of his Christ, alleluia.
Collect
O God, who open wide the gates of the heavenly Kingdom to those reborn of water and the Holy Spirit, pour out on your servants an increase of the grace you have bestowed, that having been purged of all sins, they may lack nothing that in your kindness you have promised. Through our Lord...
FIRST READING Acts 7:51-8:1a
A reading from the Acts of the Apostles
In those days: Stephen said to the people and the
elders and the scribes, "You stiff-necked people, uncircumcised in heart
and ears, you always resist the Holy Spirit. As your fathers did, so do you.
Which of the prophets did not your fathers persecute? And they killed those who
announced beforehand the coming of the Righteous One, whom you have now
betrayed and murdered, you who received the law as delivered by angels and did
not keep it." Now when they heard these things they were enraged, and they
ground their teeth against him. But he, full of the Holy Spirit, gazed into
heaven and saw the glory of God, and Jesus standing at the right hand of God;
and he said, "Behold, I see the heavens opened, and the Son of man
standing at the right hand of God." But they cried out with a loud voice
and stopped their ears and rushed together upon him. Then they cast him out of
the city and stoned him; and the witnesses laid down their garments at the feet
of a young man named Saul. And as they were stoning Stephen, he prayed,
"Lord Jesus, receive my spirit." And he knelt down and cried with a
loud voice, "Lord, do not hold this sin against them." And when he
had said this, he fell asleep. And Saul was consenting to his death.
The word of the Lord.
RESPONSORIAL PSALM Ps 31:3bc-4.6 and 7b-8a.17 and 21ab (R. 6a)
R. Into your hands, O Lord, I commend my spirit.
Or Alleluia!
Be a rock of refuge for me, a mighty stronghold to
save me. For you are my rock, my stronghold! Lead me, guide me, for the sake of your name.
R. Into your hands, O Lord, I commend my spirit.
Into your hands I commend my spirit. You will
redeem me, O LORD, O faithful God. As for me, I trust in the LORD. Let me be
glad and rejoice in your mercy.
R. Into your hands, O Lord, I commend my spirit.
 Save me in
your merciful love. You hide them in the shelter of your presence, secure from
human scheming.
R. Into your hands, O Lord, I commend my spirit.
ALLELUIA See John 6:35ab
R. Alleluia. I am the bread of life, says the Lord; he who comes to me shall not hunger. R. Alleluia.
GOSPEL John 6:30-35
A reading from the holy Gospel according to John
At that time: The people said to Jesus, "Then
what sign do you do, that we may see, and believe you? What work do you
perform? Our fathers ate the manna in the wilderness; as it is written, 'He
gave them bread from heaven to eat.'" Jesus then said to them,
"Truly, truly, I say to you, it was not Moses who gave you the bread from
heaven; my Father gives you the true bread from heaven. For the bread of God is
that which comes down from heaven, and gives life to the world." They said
to him, "Lord, give us this bread always." Jesus said to them,
"I am the bread of life; he who comes to me shall not hunger, and he who
believes in me shall never thirst.
The Gospel of the Lord.
Prayer over the Offerings
Receive, O Lord, we pray, these offerings of your exultant Church, and, as you have given her cause for such great gladness, grant also that the gifts we bring may bear fruit in perpetual happiness. Through Christ our Lord.
Communion Antiphon
If we have died with Christ, we believe that we shall also live with Christ, alleluia.
Prayer after Communion
Look with kindness upon your people, O Lord, and grant, we pray, that those you were pleased to renew by eternal mysteries may attain in their flesh the incorruptible glory of the resurrection. Through Christ our Lord.


| Cockpit Guide |
|---|
cockpit.js: HTTP Clientcockpit.js: HTTP Client — HTTP and REST API communication |
Cockpit allows access to local HTTP and REST services via this API.
http = cockpit.http(endpoint, [options]) http = cockpit.http(options)
Create a new HTTP client. The endpoint
can be a file path starting with
/
to connect to a unix socket, or it can be a port number to connect to.
The optional options
argument is a javascript plain object, and may
include:
|
Connect to an address other than localhost. Must be a valid host name or IP address. To use this option you also must provide a port number. |
|
Port number to use with "address" option, when not given in |
|
Object properties for an https connection. See
|
|
A connection identifier. Subsequent channel requests with the same identifier will try to use the same connection if it is still open. |
|
Additional HTTP headers to include with the HTTP request. This is a plain javascript object with each key as a header name, and each value as the header value. |
|
Set to Set to |
|
If set to a plain javascript object, then the connection will be an HTTPS
connection and include TLS encryption. The fields of the
|
Here is a somewhat complex example of using most of the above options
when
when calling cockpit.http()
:
http = cockpit.http({ "address": "localhost", "headers": { "Authorization": "Basic dXNlcjpwYXNzd29yZA==" }, "port": 443, "tls": { "validate": true, "authority": { "file": "/etc/pki/tls/certs/ca-bundle.crt", }, "certificate": { "data": "-----BEGIN CERTIFICATE-----\nMIIDsDCCA..." }, "key": { "data": "-----BEGIN RSA PRIVATE KEY-----\nMIIEogIBA..." } } });
request = http.get(path, [params, [headers]])
Perform an HTTP GET request for the given path
. If the params
is specified it should be a plain javascript object, which will be turned into a query string.
Optionally a plain javascript object containing headers can be included in the
headers
argument.
The return value is a promise that will complete if the request happens successfully, or fail if there's a problem.
request = http.post(path, body, [headers])
Perform an HTTP POST request for the given path
. The body
can be a string, or a javascript plain object, which will be encoded as JSON data. If
body
is undefined
or null
then an empty HTTP body
will be sent.
Optionally a plain javascript object containing headers can be included in the
headers
argument.
The return value is a promise that will complete if the request happens successfully, or fail if there's a problem.
request = http.request(options)
Perform an HTTP request. The options
can contain the following:
|
The HTTP request body. If you do not specify a body, then you must call request.input() to complete the body and allow the request to start. |
|
A javascript plain object containing HTTP headers. |
|
The HTTP method. Defaults to |
|
A javascript plain object containing query string parameters. |
|
The HTTP path. Defaults to |
The return value is a promise that will complete if the request happens successfully, or fail if there's a problem.
request.done(function(data) { ... })
This is a standard promise method. It sets up a handler to be called when the request finishes successfully.
The data
argument contains the body result of the request.
If it a string, unless the process was opened in binary mode, in which case the
data
is an array of bytes. If a
request.stream()
handler is set up, then any standard output data consumed by the handler will not
be included in the data
argument.
request.fail(function(exception[, data]) { ... })
This is a standard jQuery promise method. It sets up a handler to be called when the request fails, or returns an error code.
The exception
object passed to the handler can have the
following fields:
|
A problem code string when
a problem occurred starting or communicating with the server. This is |
|
The numeric status of the response. This is |
|
A string reason returned in the response. This is |
|
A string message returned in the response. This is |
If the request returned a response body, it will be available in
the data
argument. Otherwise this argument will be undefined
.
request.always(function() { ... })
This is a standard jQuery promise method. It sets up a handler to be called when the process completes, whether it exits successfully, fails, terminates, or exits with a failure.
request.response(function(status, headers) { ... })
This sets up a handler to be called when the HTTP request gets the initial response
from the server. The status
argument is the HTTP status integer, and the
headers
is a plain javascript object containing the headers of the
response.
request.stream(function(data) { ... })
This sets up a handler to be called when the request returns output data. The handler will be called multiple times.
Only one handler may be registered at a time. Registering an additional handler
replaces the previous one. The handler receives either string data
or
an array of binary bytes as its argument. A stream handler may return a number, which
indicates the number of characters or bytes consumed from data
. Any data
not consumed will be included again the next time the handler is called.
If a request.stream()
handler is set up, then the
request.done()
handlers will
only get any remaining data not consumed by the stream handler.
request.input(data, [stream])
This method writes data
to the HTTP request body. It is only valid
if no "body"
has been specified in
http.request() options. If stream
is true
then this function can be called again to provide further data.
request.close([problem])
Cancel the request. If problem
is specified it should be a
standard problem code string.


Data structure with instanced dynamics data for wheels.
More...
#include <PxVehicleWheels.h>
|
| | PxVehicleWheelsDynData () |
| |
| | ~PxVehicleWheelsDynData () |
| |
| void | setToRestState () |
| | Set all wheels to their rest state. More...
|
| |
| void | setTireForceShaderFunction (PxVehicleComputeTireForce tireForceShaderFn) |
| | Set the tire force shader function. More...
|
| |
| void | setTireForceShaderData (const PxU32 tireId, const void *tireForceShaderData) |
| | Set the tire force shader data for a specific tire. More...
|
| |
| const void * | getTireForceShaderData (const PxU32 tireId) const |
| | Get the tire force shader data for a specific tire. More...
|
| |
| void | setWheelRotationSpeed (const PxU32 wheelIdx, const PxReal speed) |
| | Set the wheel rotation speed (radians per second) about the rolling axis for the specified wheel. More...
|
| |
| PxReal | getWheelRotationSpeed (const PxU32 wheelIdx) const |
| | Return the rotation speed about the rolling axis of a specified wheel . More...
|
| |
| void | setWheelRotationAngle (const PxU32 wheelIdx, const PxReal angle) |
| | Set the wheel rotation angle (radians) about the rolling axis of the specified wheel. More...
|
| |
| PxReal | getWheelRotationAngle (const PxU32 wheelIdx) const |
| | Return the rotation angle about the rolling axis for the specified wheel. More...
|
| |
| void | setUserData (const PxU32 tireIdx, void *userData) |
| | Set the user data pointer for the specified wheel It has a default value of NULL. More...
|
| |
| void * | getUserData (const PxU32 tireIdx) const |
| | Get the user data pointer that was set for the specified wheel. More...
|
| |
| void | copy (const PxVehicleWheelsDynData &src, const PxU32 srcWheel, const PxU32 trgWheel) |
| | Copy the dynamics data of a single wheel unit (wheel, suspension, tire) from srcWheel of src to trgWheel. More...
|
| |
| PxU32 | getNbWheelRotationSpeed () const |
| |
| PxU32 | getNbWheelRotationAngle () const |
| |
| PxVehicleWheels4DynData * | getWheel4DynData () const |
| |
| PxU32 | getNbConstraints () const |
| | Retrieve the number of PxConstraint objects associated with the vehicle. More...
|
| |
| PxU32 | getConstraints (PxConstraint **userBuffer, PxU32 bufferSize, PxU32 startIndex=0) const |
| | Retrieve all the PxConstraint objects associated with the vehicle. More...
|
| |
Data structure with instanced dynamics data for wheels.
◆ PxVehicleWheelsDynData() [1/2]
| PxVehicleWheelsDynData::PxVehicleWheelsDynData |
( |
| ) |
|
|
inline |
◆ ~PxVehicleWheelsDynData()
| PxVehicleWheelsDynData::~PxVehicleWheelsDynData |
( |
| ) |
|
|
inline |
◆ PxVehicleWheelsDynData() [2/2]
| PxVehicleWheelsDynData::PxVehicleWheelsDynData |
( |
const PxU32 |
numWheels | ) |
|
|
private |
◆ computeByteSize()
| static PxU32 PxVehicleWheelsDynData::computeByteSize |
( |
const PxU32 |
numWheels | ) |
|
|
staticprivate |
see PxVehicleWheels::allocate
◆ copy()
Copy the dynamics data of a single wheel unit (wheel, suspension, tire) from srcWheel of src to trgWheel.
- Parameters
-
| [in] | src | is the data to be copied. |
| [in] | srcWheel | is the wheel whose data will be copied from src. |
| [in] | trgWheel | is the wheel that will be assigned the copied data. |
◆ getBinaryMetaData()
| static void PxVehicleWheelsDynData::getBinaryMetaData |
( |
PxOutputStream & |
stream | ) |
|
|
static |
◆ getConstraints()
Retrieve all the PxConstraint objects associated with the vehicle.
There is one PxConstraint per block of 4 wheels. The count can be extracted through getNbConstraints()
- Parameters
-
| [out] | userBuffer | The buffer to store the constraint pointers. |
| [in] | bufferSize | Size of provided user buffer. |
| [in] | startIndex | Index of first constraint pointer to be retrieved |
- Returns
- Number of constraint pointers written to the buffer.
- See also
- PxConstraint getNbConstraints()
◆ getNbConstraints()
| PxU32 PxVehicleWheelsDynData::getNbConstraints |
( |
| ) |
const |
|
inline |
◆ getNbWheelRotationAngle()
| PxU32 PxVehicleWheelsDynData::getNbWheelRotationAngle |
( |
| ) |
const |
|
inline |
◆ getNbWheelRotationSpeed()
| PxU32 PxVehicleWheelsDynData::getNbWheelRotationSpeed |
( |
| ) |
const |
|
inline |
◆ getTireForceShaderData()
| const void* PxVehicleWheelsDynData::getTireForceShaderData |
( |
const PxU32 |
tireId | ) |
const |
Get the tire force shader data for a specific tire.
◆ getUserData()
| void* PxVehicleWheelsDynData::getUserData |
( |
const PxU32 |
tireIdx | ) |
const |
Get the user data pointer that was set for the specified wheel.
◆ getWheel4DynData()
| PxVehicleWheels4DynData* PxVehicleWheelsDynData::getWheel4DynData |
( |
| ) |
const |
|
inline |
◆ getWheelRotationAngle()
| PxReal PxVehicleWheelsDynData::getWheelRotationAngle |
( |
const PxU32 |
wheelIdx | ) |
const |
Return the rotation angle about the rolling axis for the specified wheel.
◆ getWheelRotationSpeed()
| PxReal PxVehicleWheelsDynData::getWheelRotationSpeed |
( |
const PxU32 |
wheelIdx | ) |
const |
Return the rotation speed about the rolling axis of a specified wheel .
◆ isValid()
| bool PxVehicleWheelsDynData::isValid |
( |
| ) |
const |
|
private |
Test if wheel dynamics data have legal values.
◆ patchUpPointers()
◆ setTireForceShaderData()
| void PxVehicleWheelsDynData::setTireForceShaderData |
( |
const PxU32 |
tireId, |
|
|
const void * |
tireForceShaderData |
|
) |
| |
Set the tire force shader data for a specific tire.
- Parameters
-
| [in] | tireId | is the wheel index |
| [in] | tireForceShaderData | is the data describing the tire. |
◆ setTireForceShaderFunction()
Set the tire force shader function.
- Parameters
-
| [in] | tireForceShaderFn | is the shader function that will be used to compute tire forces. |
◆ setToRestState()
| void PxVehicleWheelsDynData::setToRestState |
( |
| ) |
|
Set all wheels to their rest state.
- See also
- setup
◆ setUserData()
| void PxVehicleWheelsDynData::setUserData |
( |
const PxU32 |
tireIdx, |
|
|
void * |
userData |
|
) |
| |
Set the user data pointer for the specified wheel It has a default value of NULL.
- Parameters
-
| [in] | tireIdx | is the wheel index |
| [in] | userData | is the data to be associated with the wheel. |
◆ setWheelRotationAngle()
| void PxVehicleWheelsDynData::setWheelRotationAngle |
( |
const PxU32 |
wheelIdx, |
|
|
const PxReal |
angle |
|
) |
| |
Set the wheel rotation angle (radians) about the rolling axis of the specified wheel.
- Parameters
-
| [in] | wheelIdx | is the wheel index |
| [in] | angle | is the rotation angle to be applied to the wheel. |
◆ setWheelRotationSpeed()
| void PxVehicleWheelsDynData::setWheelRotationSpeed |
( |
const PxU32 |
wheelIdx, |
|
|
const PxReal |
speed |
|
) |
| |
Set the wheel rotation speed (radians per second) about the rolling axis for the specified wheel.
- Parameters
-
| [in] | wheelIdx | is the wheel index |
| [in] | speed | is the rotation speed to be applied to the wheel. |
◆ PxVehicleDrive4W
◆ PxVehicleDriveTank
◆ PxVehicleUpdate
| friend class PxVehicleUpdate |
|
friend |
◆ PxVehicleWheels
◆ mNbActiveWheels
| PxU32 PxVehicleWheelsDynData::mNbActiveWheels |
|
private |
Number of wheels (mNbActiveWheels <= (mNbWheels4*4))
◆ mNbWheels4
| PxU32 PxVehicleWheelsDynData::mNbWheels4 |
|
private |
Number of blocks of 4 wheels.
◆ mPad
| PxU32 PxVehicleWheelsDynData::mPad[3] |
|
private |
◆ mTireForceCalculators
| PxVehicleTireForceCalculator* PxVehicleWheelsDynData::mTireForceCalculators |
|
private |
Shader data and function for tire force calculations.
◆ mUserDatas
| void** PxVehicleWheelsDynData::mUserDatas |
|
private |
◆ mWheels4DynData
| PxVehicleWheels4DynData* PxVehicleWheelsDynData::mWheels4DynData |
|
private |
Dynamics data arranged in blocks of 4 wheels.
The documentation for this class was generated from the following file:


|
|
For fun...I'm currently working on a consent-centric party game app for mobile, which can be played remotely or in person. I created a web application that detects pixel color in an image and changes the color palette for stylized images. I create digital artwork using Procreate, and physical drawings with pencils and markers - predominately inspired by nature and song lyrics. I developed and maintain a web application that matches users to concerts near them based on their music taste. I captained the Official Maryland's Women's Ultimate Frisbee Team, and now play Ultimate around the world. I was the lead developer and designer of the iPhone application Park UMD, which was successfully released in early June, 2015. For work...I've worked at 6 startups, and have lead technical teams since 2020 I have experience in a wide array of coding languages and tech stacks, but have a soft spot for Typescript and Javascript. I completed five internships by the start of my Senior year, in varying fields and under drastically different roles. |
Leading a growing team of engineers in the development of solutions for ordering, inventory, and shipping. Regularly developing full stack features and bug fixes as well as leading large scale migrations to green field applications - using technologies such as Mongo DB, Postgres, Python (Django and Flask), ReactJS and Typescript. In addition to being a key contributor, actively creating and communicating my team's roadmap and long term vision to the entire organization and external stakeholders.
Acted as an engineer on the Content team at Storyblocks, improving our contributors' experience on our contributor portal, as well as the customer experience on our flagship sites. I'm coding predominately in Typescript, Javascript (React, Angular, and EJS), PHP, Java, NoSql, SQL, Python and a little Scala.
One of two Front End engineers developing an application called Agnes, which strives to simplify and improve how students find events in and around campus. Currently using the Angular Framework and Ionic for mobile development, while also leading the development of a browser version utilizing React Redux.
Full Stack engineer developing a responsive call center software which utilizes React Redux, Flux, and Postgres. My primary projects involved improving admin interaction with the application by simplifying the motions needed to complete tasks, and improving the security of the application so clients may have safe access to the admin dashboards.
Full Stack support engineer assisting clients with any and all issues they experience with the Appian Software Product. In my first year, I closed over 500 cases, earned the title of Dedicated Engineer for a Premier Support Client, wrote over 40 Knowledge Base Articles, and added over a dozen code improvements to our own Support Case Management Application.
Optimized client websites and AdWords accounts to increase visitor traffic, conversions, and help clients meet their monthly goals. Additionally, provided consultations for clients on how to improve their digital presence by editing websites, creating s, and managing social media accounts.
Served in the Financial Services Office to aid Freddie Mac in the development of a completely new product service offering. In the process, strengthened my skills in SQL, database management, Microsoft Excel, Git, and Agile.
Developed an iPhone application to assist University of Maryland students, faculty, and visitors with parking on-campus and avoiding costly parking tickets from the UMD Department of Transportation.
Organized, designed, and built a User Acceptance Testing form to ease the transfer of information for Discovery’s in-house database: the Discovery Hive. Additionally, created a database for Discovery Hive metrics to assist business intelligence representatives in determining progress between releases and pinpoint areas for improvement based on current
Performed comprehensive database management in editing and completing projects, assisted in the completion of project proposals, and executed the coordination of an individual project to integrate multiple sectors of the company and increase productivity
Planned and led individual projects committed to brand recognition to demonstrate understanding of marketing and improve skills in the field. Worked with a marketing team to propose and implement events dedicated to endorsing the restaurant, utilized social media channels and traditional media to increase sales and customer satisfaction and hosted events to promote the Bobby’s Burger Palace Brand
PersonalDouble Degree in Marketing and Information Systems with a Minor in Spanish Robert H. Smith School Business Honors Member University Scholars Certificate Primannum Honor Society Member University of MarylandRanked the 20th in the nation amongst Public Research Universities in 2016 Robert H. Smith School of Business ranked 21st for the Best Undergraduate Program in the Nation in 2016 Information Systems Major ranked 6th in the Nation in 2016 |
SEO
Graphic Design
Procreate, Affinity Designer & Photo, Adobe Photoshop & Illustrator
Traditional Marketing
Press Release Creation
Social Media Marketing
Promotional Event Execution
Google AdWords and Analytics
Search Engine Optimization
Branding
Email Campaign Design
Languages: Javascript, HTML, CSS, Git, SQL, Swift, Bash, PHP, Python, Java, Visual Basic, SAIL
Website & App Design
Frameworks & Libraries: Ionic, ReactJS, Redux, AngularJS
Amazon Web Services
Openswan VPN
Agile & Waterfall Methodologies
MVC Architectural Patterns
Software Development Lifecycle
Adobe Creative Suite
GeoCoding
Database Management
Sharepoint
Microsoft Office
Team Lead and Mentor
SCRUM Leader
Time Management
Project Management
Leadership
Priority Allocation


Hackney Playbus collects this information for monitoring, analysis and data collection purposes. Your information may be disclosed to other government agencies responsible for legislation relating to children and may be shared with your local children’s centre. Your contact information may be used to keep you informed of Hackney Playbus services. Personal information collected in this form will only be used for the purposes stated here. By completing this registration form it is deemed that you understand and consent to the purposes which the information may be used for.
I, the carer completing this form, give my consent for the children named in this form to be photographed during Playbus sessions by Hackney Playbus staff, volunteers and partner organisations. I consent to photographs of my children being displayed on the Hackney Playbus website, Facebook and Twitter and also in any advertising material for the Hackney Playbus, their funders or partner organisations.


--- layout: default title: Market Street Prototyping Festival ---
Up to 50 projects will be selected by our jury. Selections will be announced June 30.


We offer you the appropriate environment to implement and publish your robotic applications!
About RAPP architecture
RAPP adopts a distributed architecture, where the platform and the store are on the cloud, and the client is on the robot. Together, the controller executing on the robot and the controller executing on the cloud, make up a Robotic Application (RApp).
The RAPP platform is composed of six major components with different levels of inter-connectivity:
The RAPP Store , which indexes a collection of RApps which may be downloaded by RAPP users on their robots. It is responsible for: Processing new RApps (Building and Packaging), Indexing and Distributing RApps, Updating RApps.
The RAPP Improvement Center, which can perform a variety of Machine Learning and Data Mining tasks.
The Centralized DB, which acts as the central repository of data required for the RAPP Platform. These correspond to processrelated data, RApp specific data, and user-related data.
The Knowledge Base, which is implemented via an ontology scheme, where anonymous data are stored in order to implement machine learning algorithms.
The Offline Learning Processes, which involves machine learning components that periodically analyse data stored in the Knowledge Base and the Centralized DB along with metadata and usage logs in order to extract meaningful knowledge.
The RApp execution workspace, where the cloud agents are deployed and where specific tasks programmed by the developer of a RApp can be executed, which serves a high performance computing entity.
What bridges all the entities and users, is in fact the RAPP API. Now, the developer should be aware of which parts run on the robot, and which on the cloud, but should not have to dig deep into lower level development of how they intercommunicate, interact or synchronize.
Things you need to know
As a developer, you need to create an account and log in to the RAPP store in an authenticated manner, in order to become able to submit RApps via an interface. The submitted RApps are cross-compiled for the supported robots, packaged and indexed. Then, they can be distributed at the corresponding robots. If any errors occur during this procedure, you are informed in order to correct them and resubmit the application.
A Robotic Application can be submitted as pure C++ code, a ROS package (using C++ or Python) and pure JS code. Thus in the cases of C++ code and the ROS package, the compilation is needed, whereas in the JS case the Store proceeds directly to the packaging. The process identifies the source, binaries and dependant components of a RApp, and highlights the metadata procedures required in order to validate and further utilize the RApp within the RAPP Platform.
In the RAPP store website, a list of the available robots and their capabilities can be retrieved from the centralized DB and be accessible to potential developers to help you develop your RApps.
RApp-related information like compatibility with certain robot models and their respective software and firmware versions, dependencies on other RApps etc. are stored in the Centralized DB on the platform side and are accessible by the RAPP Store.
So, how can RAPP help you?
You can take the advantage of the provided infrastructure to easily build and include machine learning and personalization techniques to their applications.
You can easily set up your application using the RAPP store.
Your application will be uploaded to the RAPP store and everyone will have access to it.


\( \def\RR{\bf R} \def\real{\mathbb{R}} \def\bold#1{\bf #1} \def\d{\mbox{Cord}} \def\hd{\widehat \mbox{Cord}} \DeclareMathOperator{\cov}{cov} \DeclareMathOperator{\var}{var} \DeclareMathOperator{\cor}{cor} \newcommand{\ac}[1]{\left\{#1\right\}} \)
Estimating Brain Information Flow
via Pathway Lasso
Yi Zhao, Xi (Rossi) Luo
Brown University
Department of Biostatistics
Center for Statistical Sciences
Computation in Brain and Mind
Brown Institute for Brain Science
CMStatistics, Seville, Spain
December 11, 2016
Funding: NIH R01EB022911; NSF/DMS (BD2K) 1557467; NIH P20GM103645, P01AA019072, P30AI042853; AHA
Authors
Yi Zhao
(4th Yr PhD Student, on the job market this year)
Xi Luo
Brown University
Task fMRI
- Task fMRI: performs tasks under brain scanning
- Story vs Math task:
listen to story (treatment stimulus) or math questions (control), eye closed
- Not resting-state: "rest" in scanner
Goal: how brain processes story/math differently?
fMRI data: blood-oxygen-level dependent (BOLD) signals from each
cube/voxel (~millimeters),
$10^5$ ~ $10^6$ voxels in total.
fMRI Studies
Time 1
2
…
~200
⋮
…
⋮
…
This talk: one subject, two sessions (to test replicability)
Network Model with Stimulus
Question: quantify
red,
blue, and other pathways
from stimulus to orange outcome circle/region Heim et al, 09
Pathway=Activation+Connectivity
- Activation: stimulus $\rightarrow$ brain region activity
- Connectivity: one brain region $\rightarrow$ another region
- Whether not two or more brain regions "correlate"
- Pathway: stimulus $\rightarrow$ brain region A $\rightarrow$ region B
- Strong path: strong activation
and strong conn
- Zero path: zero activation
or zero conn, including
- Zero activation + strong conn = zero
- Strong activation + zero conn = zero
Mediation Analysis and SEM
$$\begin{align*}M &= Z a + {U + \epsilon_1}\\ R &= Z c + M b + {U g + \epsilon_2}\end{align*}$$
- Pathway effect: $a \times b$indirect; residual: $c$direct
- Mediation analysis
- Baron&Kenny, 86; Sobel, 82; Holland 88; Preacher&Hayes 08; Imai et al, 10; VanderWeele, 15;...
Mediation Analysis in fMRI
- Parametric Wager et al, 09 and functional Lindquist, 12 mediation, under (approx.) independent errors
- Stimulus $\rightarrow$ brain $\rightarrow$ user reported ratings, one mediator
- Usual assumption: $U=0$ and $\epsilon_1 \bot \epsilon_2$
- Parametric and multilevel mediation Yi and Luo, 15, with correlated errors for two brain regions
- Stimulus $\rightarrow$ brain region A $\rightarrow$ brain region B, one mediator
- Correlations between $\epsilon_1$ and $\epsilon_2$
- This talk: multiple mediator and multiple pathways
- High dimensional: more mediators than sample size
- Alt: dimension reduction by arXiv1511.09354 Chen, Crainiceanu, Ogburn, Caffo, Wager, Lindquist, 15
Full Pathway Model
- Stimulus $Z$, $K$ mediating brain regions $M_1, \dotsc, M_K$, Outcome region $R$
- Strength of activation ($a_k$) and connectivity ($b_k$, $d_{ij}$)
- Too complex, even for small $K = 2$ Daniel et al, 14
Reduced Pathway Model
$$\begin{align}M_k & = Z A_k + E_{1k},\, k=1,\dotsc, K\\ R & = Z C + \sum_{k=1}^{K} M_k B_k + E_2 \end{align}$$
- $A_k$: total inflow to mediator $M_k$; $B_k$: total conn
- Pathway effect: $A_k \times B_k$; Residual: $C$
Relation to Full Model
- Proposition: Our "total" parameters has explicit forms of "individual" flow parameters in the full model
- Proposition: Our $E_k$'s are correlated, but won't affect estimation (will affect variance)
- Reduced model: a step to select spatial mediators
- Strong overall inflow and strong conn flow
- Favor reduced: challenging to determine the temporal order because of low temporal resolution
Regularized Regression
- Minimize the penalized least squares criterion
$$\sum_{k=1}^K \| M_k - Z A_k \|_2^2 + \| R - Z C - \sum_k M_k B_k \|_2^2 + \mbox{Pen}(A, B)$$
The choice of penalty $\mbox{Pen}(\cdot)$ to be discussed
- All data are normalized (mean=0, sd=1)
- Want to select sparse
pathways for high-dim $K$
- Alternative approach: two-stage LASSO Tibshirani, 96 to select sparse
inflow and
connection separately: $$ \sum_{k=1}^K \| M_k - Z A_k \|_2^2 + \lambda \sum_k | A_k | \\ \| R - Z C - \sum_k M_k B_k \|_2^2 + \lambda \sum_k |B_k| $$
Penalty: Pathway LASSO
- Select strong pathways effects: $A_k \times B_k$
- TS-LASSO: shrink to zero when $A$&$B$ moderate but $A\times B$ large
- Penalty (prototype) $$ \lambda \sum_{k=1}^K |A_k B_k| $$
- Non-convex in $A_k$ and $B_k$
- Computationally heavy and non-unique solutions
- Hard to prove theory
- We propose the following general class of penalties$$ \lambda \sum_{k=1}^K ( |A_k B_k| + \phi A_k^2 + \phi B_k^2) $$
Theorem $$v(a,b) = |a b| + \phi (a^2 + b^2)$$ is convex
if and only if $\phi\ge 1/2$. Strictly convex if $\phi > 1/2$.
Contour Plot of Different Penalties
-
Non-differentiable at points when $a\times b = 0$
- Shrink $a\times b$ to zero
- Special cases: $\ell_1$ or $\ell_2$
- TS-LASSO: different $|ab|$ effects though $|a|+|b|$ same
Algorithm: ADMM + AL
- SEM/regression loss: $u$; Non-differnetiable penalty: $v$
- ADMM to address differentiability $$ \begin{aligned} \text{minimize} \quad & u(\Theta,D)+v(\alpha,\beta) \\ \text{subject to} \quad & \Theta=\alpha, \\ & D=\beta, \\ & \Theta e_{1}=1, \end{aligned}$$
- Augmented Lagrangian for multiple constraints
- Iteratively update the parameters
- We derive theorem on explicit (not simple) updates
Complications
- Mixed norm penalty $$\mbox{PathLasso} + \omega \sum_k (|A_k| + |B_k|)$$
- Tuning parameter selection by cross validation
- Reduce false positives via thresholding Johnston and Lu, 09
- Inference/CI: bootstrap after refitting
- Remove false positives with CIs covering zero Bunea et al, 10
Simulations
- Our PathLasso compares with TSLasso
- Simulate with varying error correlations
- Tuning-free comparison: performance vs tuning parameter (estimated effect size)
- PathLasso outperforms under CV
Pathway Recovery
ROC
F1 Score
MSE
Our PathLasso (red) outperforms two-stage Lasso (blue)
Other curves: variants of PathLasso and correlation settings
Data: Human Connectome Project
- Two sessions (LR/RL), story/math task Binder et al, 11
- gICA reduces voxel dimensions to 76 brain maps
- ROIs/clusters after thresholding
- Apply to two sess separately, compare replicability
- Jaccard: whether selected pathways in two runs overlap
- $\ell_2$ diff: difference between estimated path effects
- Tuning-free comparisons
Jaccard
$\ell_2$ Diff
Regardless of tuning, our PathLasso (red) has smaller cross-sess diff (selection and estimation) than TSLasso (blue)
Stim-M25-R and Stim-M65-R significant shown largest weight areas
- M65 responsible for language processing, larger flow under story
- M25 responsible for uncertainty, larger flow under math
Summary
- High dimensional pathway model
- Penalized SEM for pathway selection and estimation
- Convex optimization for non-convex products
- Sufficient and necessary condition
- Algorithmic development for complex optimization
- Improved estimation and selection accuracy
- Higher replicability in HCP data
- Manuscript:
Pathway Lasso (arXiv 1603.07749)
Thank you!
Slides at: bit.ly/CMStat16
More info: BigComplexData.com