Getting Honest with God – Connection!
"Help us, God our Savior, for the glory of your name; deliver us and forgive our sins for your name's sake" (Psalm 79:9).
Desperation should cause us to get honest with God. One pastor was so desperate that he asked the entire congregation to prayerfully examine themselves and confess any sin. Things got quiet and still as sins were expressed openly.
Finally, one man said, "We mistreated a former staff member, our former youth pastor. We owe him and his family an apology. We need to seek his forgiveness. We need to make things right." Others agreed, yet no one knew where he was or how to reach him, but they drafted a letter of apology so it would be ready when they located him.
A few weeks after that meeting, a member of that church was attending an "Experiencing God" weekend and the leader asked those attending to share what God was doing in their churches. This man could not wait to share how mightily God was moving. As he shared about people being saved and lives transformed, he also told how they had hurt and offended a former staff member. He said they were trying to locate the man to apologize. Suddenly, from the back of the room, a man started to weep audibly and uncontrollably.
The room became quiet. The weeping man said, "That's me. I'm that former youth pastor." There was stunned silence for a moment and then reconciliation poured forth. One pastor's sense of desperation for his church to be right with God led to reconciliation and forgiveness. A burden was lifted as one church sought to get right with a former staff member, so that they could continue moving forward with God.
When we get comfortable in our service to God, that's when we need to be cautious. You cannot be comfortable and desperate at the same time. Spiritual desperation comes only when we realize nothing, absolutely nothing, can satisfy us other than Jesus Christ. When we cry out to God in desperation, God will respond. But then we must follow. Where and how He will lead is amazing.
Father, I want my heart to be so desperate for You…above all other things, people or situations…that I will cry out for revival! It begins with me…in my own sin-sick heart. Show me the evil, dark places within me that must be brought into the light so that I can openly confess them. Reveal to me the wrongs that I can right through forgiveness and grace. Refresh and restore my soul to live fully for Jesus Christ each and every moment of my short life on this earth so that others will be drawn to the light of Your presence and captivated by all that You are!
–Adapted from Praying with Fire: Seeking His Presence through the Revival Passages of Scripture by Mark Partin. This book is available at prayershop.org. Use the code CONPSP3 at checkout to receive an additional 10% discount.
Praise God, the changer of times and seasons (Dan. 2:21), who is in control of all of history. Give thanks for this new day. Confess any misuse or waste of time. Commit yourself to taking hold of today's opportunities and to enjoying the special pleasures God provides during this season. Ask him to guide you to make wise and efficient use of your time.
Pray that your church leaders will be protected from overloaded schedules. Ask God to give them wisdom as they lead the church and care for their other concerns.
Many of the resources produced by PrayerShop Publishing are available as PDF downloads at reduced prices.


text:
The Lion of the South
Noble Cause
Liberty and Destiny
The Gray Ghost of Civil War Virginia
Favorite Charities
149th anniversary of the Gettysburg Address
by Jessica James | Nov 19, 2012 | Uncategorized | 0 comments
General Lee in the Remembrance Day Parade.
Today is an historic day in Gettysburg – the anniversary of the day President Abraham Lincoln delivered his famous address while dedicating the National Cemetery in 1863.
The release of Steven Spielberg's movie has brought renewed interest to this historic day, especially since Spielberg himself is in Gettysburg to deliver the keynote address at the annual "Remembrance Day" ceremony at the cemetery.
On Saturday I attended the Remembrance Day Parade, which is one of my favorite events in Gettysburg. Remembrance Day is dedicated to honoring the slain of Gettysburg, the veterans of that horrific battle, and the President who led us through it.
Parade coming down Baltimore Street.
The weather was fantastic for a November day in Pennsylvania. I've been to many Remembrance Day events that were freezing, windy, sleeting and bone-chilling cold.
As you may know, the Battle of Gettysburg was fought in July of 1863, and was the single bloodiest battle of the Civil War. Over the course of three days, more than 45,000 men were killed, injured, captured or went missing.
Charged by Pennsylvania's governor, Andrew Curtin, to care for the Gettysburg dead, an attorney named David Wills bought 17 acres of pasture to turn into a cemetery for the more than 7,500 who fell in battle.
Wills invited Edward Everett, one of the most famous orators of the day, to deliver a speech at the cemetery's dedication. Almost as an afterthought, Wills also sent a letter to Lincoln—just two weeks before the ceremony—requesting "a few appropriate remarks" to consecrate the grounds.
General JEB Stuart & Col. John Mosby.
At the dedication, the crowd listened for two hours to Everett before Lincoln spoke. Lincoln's address–just 272 words long–lasted just two or three minutes. The speech reflected his redefined belief that the Civil War was not just a fight to save the Union, but a struggle for freedom for all, an idea Lincoln had not championed in the years leading up to the war.
It's ironic that the conclusion to his speech was: "The world will little note, nor long remember what we say here, but it can never forget what they did here. It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced. It is rather for us to be here dedicated to the great task remaining before us—that from these honored dead we take increased devotion to that cause for which they gave the last full measure of devotion—that we here highly resolve that these dead shall not have died in vain—that this nation, under God, shall have a new birth of freedom—and that government of the people, by the people, for the people, shall not perish from the earth."
I'm so lucky, as an historical fiction author, to live in this area and get to see these great annual events. Next year, of course, is the 150th anniversary of both the battle and the Gettysburg Address so they will be even bigger than usual. Estimates are that the anniversary events will draw four million people to this small town!
I hope everyone has a wonderful Thanksgiving holiday! Stay safe!
Jessica James
JOIN IN ON THE FUN!
Sign up for my newsletter to receive the latest updates and promotions (and free stuff).
Books on I-Tunes
Follow Jessica James
Order An Authorgraph
Follow Jessica James's board Southern Plantations on Pinterest.
150th anniversary 150th civil war amelia island american civil war award-winning novel battle of gettysburg book signing brandy station civil war civil war love story civil war novel civil war romance Confederacy confederacy shades of gray Confederate confederate heritage month confederate history confederate history month gettysburg gone with the wind heritage historical fiction historical fiction author historical fiction novel historical romance history jeb stuart Jessica James john esten cooke award john mosby john singleton mosby lincoln meant to be memorial day mosby noble cause remembrance day robert e. lee romance sesquicentennial Shades of Gray Uncategorized valentine's day Virginia war between the states
Look Inside SHADES
Look Inside ABOVE & BEYOND
© 1996-2018 Jessica James

redpajama_set_name: RedPajamaCommonCrawl


These are the zombie cars.
These are the cars that died ages ago, forgotten and unwanted by the American masses. They are the Chrysler Pacifica, the Dodge Magnum, the Pontiac Aztek, and the Chevy TrailBlazer. There are many more, but today it's these cars that have caught our attention.
Because they are back from the dead and living among us once more.
The source of their surprise resurrection might be a little shocking. It's not the original owners looking to experience the vehicles they let get away. No, this time it's their kids.
It's the new generation, the group known as the millennials, who are snatching up these old dead cars and bringing them back to life.
Automakers are desperate to get the youngest generation into their showrooms to test-drive their latest wares. To cater to the perceived needs of young people, car companies have integrated every conceivable piece of technology into new automobiles while designing them with a creative edge and pricing them competitively.
As it turns out, millennials do indeed want good deals, but many are turning to yesterday's cars to find them.
Millennials are more practical used-car shoppers than we might otherwise credit them…. They may not go into the shopping process targeting these lesser-known vehicles, but when they see how their price tags stack up against other, better-known vehicles, they suddenly become a lot more attractive.
It's the cars mentioned above that have the highest take rates among young people, with the infamous Aztek's second life credited to its "Breaking Bad" fame.
Here's what's really interesting, though: Those old cars have the technological aptitude of a grapefruit, while their new owners can't remember a world without Siri. Those old cars have no Bluetooth, no USB connection, and no touchscreen interface. Some of them probably even lack power windows.
How can tech-savvy kids live in a smart world while driving a dumb car?
As it turns out, there are a couple of solutions for that.
Verizon has a new device called Hum, which can turn these older cars into Internet-connected vehicles.
Subscribers simply install hum through an onboard diagnostic (OBD) reader that is plugged into the vehicle's OBD port, and a Bluetooth-enabled device that is clipped to the visor. The monthly subscription also includes a smartphone app allowing subscribers to monitor their vehicle health, contact help, and manage maintenance needs, even when they are not behind the wheel.
The service costs $14.99 per month and is available to anyone.
AT&T also has a device, called Mobley, which plugs into the OBD port on most 1996 and newer cars and uses a 4G LTE connection to create a Wi-Fi signal that's on whenever the car is on. Unlike Hum, an AT&T service contract is required to use the device.
With technology like this, any car can now be raised from the dead and thrive in this modern world.
Would you want modern technology in your older car?
This entry was posted in Car Accessories, Car Industry News, Car Minded, Car Shopping, Domestic Cars, General Chat, United States, Used Cars and tagged at&t mobley, breaking bad, pontiac aztek, technology older cars, used car shopping, verizon hum. Bookmark the permalink.


Body Waxing is recommended to begin 3-6 months before the wedding to ensure smooth, long lasting results that last through the wedding and honeymooon! Hair grows back softer, smoother, and is long lasting. Be worry free for all of your occasions!
A sugar scrub is recommended in the shower 2-3 times per week to prevent ingrown hairs and help hair grow back softer.
Facial waxing should be tried at least 2 times before the big day to ensure that there is no reaction or sensitivity. Waxing can be done early in the week on the week of the wedding.
Lash Extensions: Lash Extensions are a gorgeous, easy way to get fuller, longer, more voluminous lashes for your wedding day. Lash Extensions are appied individually to each of your natural lashes and can be kept up by having them filled every 2-3 weeks. There is no need to wear mascara.
Lash Lift: Lash Lift is a service that enhances your NATURAL lashes without adding extensions. Lash Lift curls and lifts your lashes from the root making them appear longer and perfectly curled. A Lash Tint is then applied to the lashes to darken and make the lashes pop. Lash Lift lasts 6-8 weeks or more and Tint lasts 3-4. This is a very low maintenece service with great results! Mascara can be worn after 24 hours. This service is perfect for weddings and ideal for makeup-less vacations.
Ultimate Lash Lift: This service is a combination of Lash Lift and Extensions. Extensions are applied on the outer third of lashes after a Lash Lift and Tint to form a cat eye, making outer lashes longer and voluminous.
Engagement and Bridal Makeup is available and we travel all over Wisconsin! Makeup packages include Makeup Application (Brush or Airbrush), Strip Lashes if desired, and up to 20 miles of travel from either of our locations!
We use an array of brands including MAC, Kevyn Aucoin, TEMPTU, and many more of the best quality available.


Is there anything Amy Jo Martin hasn't done? She is a successful CEO, a speaker, a best-selling author, an investor, and a podcast host. I, for one, am very glad my daughters will have women like Amy Jo to look up to as they grow up and aspire for greatness. I loved chatting with Amy Jo about a number of things—about her life, her career, working with celebrities like Dwayne "The Rock" Johnson, hosting a successful podcast, #SpreadSerotonin, and so much more. Buckle up, this is a good one!
Follow Amy Jo on Twitter and Instagram. Read more of her extensive bio here. Also, buy her book! She sent me a copy a while back and it's fantastic.


Spring Thing — Independence. Exploration. Community.
I should expect this by now, after twenty years of working with kids.
Yet it still takes me by surprise. It all just sneaks-up, right about now. During the final twelve or seven or three days of every year.
First, a kid who seemed really happy to ignore me all year, suddenly joins me outside - while I'm trying to get a kite airborne - and engages me in a rather lengthy and amazingly human conversation.
Then another, someone I've known for a while, begins jamming with me on this whole different level. Confident, relaxed. We're trading chops and truly making music for the first time. Communicating in this whole new dimension.
And today, and during this past week, a trail of kids have been stopping by to tell me about things they'd like to accomplish next year. Things they want to do. Bigger, better, more challenging things they would like to get done at the Center.
Hearing all these ideas and dreams and experiencing these last minute Spring breakthroughs, I guess it makes me reflect a bit too. Imagining how I might become a more effective staff for everyone here, when our Fall semester rolls around.
The last minute progress and future ambitions streaming in from our members during these final days of this incredible 2015/16 Macomber year will stay with me.
I take these words and actions seriously and I will revisit them all in the fall. I'll do what I can to keep the ball rolling with my Spring breakthroughs and do what I can to help the other's ideas for the future actually happen.
From what I've seen, working with all kinds of students over these years, about half of the kids will still want to act on their Spring resolutions next Fall.
Hey, I'd be a slimmer, healthier and much more muscular staff member if I'd followed through on every resolution I ever made.


text:
module ReadOnly.EqualitySpec (main, spec) where

import Test.Hspec
import Test.QuickCheck
import PolyGraph.Common
import PolyGraph.Buildable
import PolyGraph.Buildable.Properties
import PolyGraph.Common.PropertySupport
import qualified PolyGraph.ReadOnly.Graph.Properties as GProps
import qualified PolyGraph.ReadOnly.DiGraph.Properties as DiGProps

import PolyGraph.ReadOnly.DiGraph.DiGraphEquality ((~>#==))
import PolyGraph.ReadOnly.Graph.GraphEquality ((~#==))

import qualified Instances.ListGraphs as List
import qualified Instances.EdgeCountMapGraph as Adj
import qualified Instances.DiGraph.DiEdgesByVertexMap as Indx

main :: IO ()
main = hspec spec

spec :: Spec
spec = do
  describe "di-edgeCount equality (~>#==)" $ do
    it "is reflexive" $ property $
            (\(mixedEsAndVsBag :: (MultiOBag Int)) ->
                  let graph :: Indx.DiEdgeListByVertexMap Int (OPair Int)
                      graph = buildGraph emptyGraph (getMix mixedEsAndVsBag)
                  in (graph ~>#== graph)
            )
    it "two graph types with the same forgetfulness created the same way are equal" $ property $
            (\(mixedEsAndVsBag :: (MultiOBag Int)) ->
                  let graph1 :: Indx.DiEdgeListByVertexMap Int (OPair Int)
                      graph1 = buildGraph emptyGraph (getMix mixedEsAndVsBag)
                      graph2 :: Adj.EdgeCountMapDiGraph Int
                      graph2 = buildGraph emptyGraph (getMix mixedEsAndVsBag)
                  in (graph1 ~>#== graph2)
            )

  describe "edgeCount equality (~#==)" $ do
    it "is reflexive" $ property $
            (\(mixedEsAndVsBag :: MultiUOList Int) ->
                  let graph :: List.Edges Int (UOPair Int)
                      graph = buildGraph emptyGraph (getMix mixedEsAndVsBag)
                  in (graph ~#== graph)
            )
    it "two graph types with the same forgetfulness created the same way are equal" $ property $
            (\(mixedEsAndVsBag :: MultiUOList Int) ->
                  let graph1 :: List.Edges Int (UOPair Int)
                      graph1 = buildGraph emptyGraph (getMix mixedEsAndVsBag)
                      graph2 :: Adj.EdgeCountMapGraph Int
                      graph2 = buildGraph emptyGraph (getMix mixedEsAndVsBag)
                  in (graph1 ~#== graph2)
            )

redpajama_set_name: RedPajamaGithub


text:
\section[Introduction]{Introduction} \label{sec:intro}

In recent years, deep learning methodologies have become the standard approach for prediction problems. For example, \cite{he2016deep} broke previous benchmarks by developing deep neural networks with over a hundred hidden layers; this was made possible by an innovation brought upon by a simple adjustment of the algorithm -- adding the output of a previous layer back into the layers following it. Another set of examples can be found in any one of the annual ImageNet Large-Scale Visual Recognition Challenges \citep{krizhevsky2012imagenet, russakovsky2015imagenet} where neural networks are consistently on the podium. These innovations naturally sparked the development of software that supplied users with an arsenal of tools to apply these methods.

There is a wide array of software available in multiple programming languages that implements a variety of methods in deep learning and neural networks.  For example, \proglang{R} packages \pkg{nnet} \citep{nnet} and \pkg{neuralnet} \citep{neuralnet} are standard sets of tools in the training of and prediction from neural networks using the Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm and backpropagation, respectively.  Both of these allow for some flexibility in terms of user selected activation functions and error measurements, but vastly more broad selections of tools are available within the \pkg{RSNNS} \citep{RSNNS} and \pkg{keras} \citep{keras} application programming interfaces (API), which may be used in both \proglang{R} and \proglang{Python}.  Both of these make detailed user customization possible and are intended to facilitate the development of deep learning models and methodologies.

Central to this paper is functional data analysis (FDA), an area of modern applied statistics that has witnessed swift development due to its ability to deal with a large and distinct class of statistical problems.  In particular, it is often the case that data is collected at high resolution at many points in space or time, resembling and being treated as a smooth function - this is known as functional data.  FDA is used instead of the standard approach of analysing single points when we are interested in framing an analysis of a set of points as if they are samples from a specific curve.

Presently, the primary software for FDA in any programming language is the \pkg{fda} package \citep{fdapkg} in \proglang{R}, designed to accompany the textbooks of \cite{Ramsay05} and \cite{ramsay2009}.  The main functionality within the package revolves around functional regression, allowing users to fit regression models where one or several of the response and explanatory variables are functions instead of scalar valued.  Several packages in \proglang{R} build upon this base by extending standard statistical methods to functional data.  For example, \pkg{funHDDC} \citep{funHDDC} and \pkg{funFEM} \citep{funFEM} handle functional clustering, \pkg{FDboost} \citep{FDboost} applies gradient boosting in functional regression and \pkg{GPFDA} \citep{GPFDA} incorporates functional regression as the mean response in Gaussian processes, among other packages. Another library, \pkg{fda.usc} \citep{fda.usc}, streamlines the fitting process of many common functional modelling approaches such as non-parametric functional regression \citep{ferraty2006nonparametric} and functional partial least squares methods \citep{aneiros2006semi}. Additionally, the \pkg{BFDA} package \citep{BFDA} in \proglang{MATLAB} provides a library for Bayesian FDA.

To the best of our knowledge, the applications of these packages do not extend to include deep learning models.  For this reason, this paper introduces the \pkg{FuncNN} package, which allows users to include functions as input variables in neural networks and implements the theoretical discussion in \cite{thind2020deep} and \cite{rossi2005functional}. This methodology has been shown to outperform many other functional and multivariate methods in a number of real world and simulated examples as seen in \cite{thind2020deep}.

The \pkg{FuncNN} package introduces several functions. The primary function \fct{fnn.fit}, grants users the ability to effortlessly generate models for their data; they also gain access to several customization options in the form of hyperparameters. The output of this function can be acted upon by several other functions within the package such as \fct{fnn.predict} and \fct{fnn.fnc} which serve to be predictive and visualization functions. Moreover, we introduce tuning and cross-validation functions aptly named \fct{fnn.tune} and \fct{fnn.cv}, respectively. The package is readily available on CRAN can be installed as follows:
\begin{CodeChunk}
\begin{CodeInput}
R> install.packages("FuncNN")
\end{CodeInput}
\end{CodeChunk}
Or through GitHub using the \pkg{devtools} \citep{devtools} package:
\begin{CodeChunk}
\begin{CodeInput}
R> devtools::install_github("b-thi/FuncNN")
\end{CodeInput}
\end{CodeChunk}
The rest of the article is organized as follows: \hyperref[sec:bg]{Section 2} explores some of the theoretical background associated with the package. In \hyperref[sec:fit]{Section 3}, the bulk of the functions are presented, including the model building and prediction functions; some visualization tools are also showcased with accompanying examples. In \hyperref[sec:cv]{Section 4}, helper functions such as those for cross-validation and tuning are detailed. Lastly, \hyperref[sec:conc]{Section 5} includes concluding thoughts and scheduled updates for the package.

\section[Theoretical Background]{Functional neural networks (FNN)} \label{sec:bg}

The conventional neural network is a contiguous combination of hidden layers, each of which contains some number of neurons. Let $n_{u}$ denote the number of neurons in the $u$-th hidden layer. We can define the first hidden layer (denoted by the superscript) as: $\boldsymbol{v}^{(1)} = g\left(\boldsymbol{W}^{(1)}\boldsymbol{x} + \boldsymbol{b}^{(1)}\right),$ where $\boldsymbol{x}$ is a vector of $J$ covariates, $\boldsymbol{W}^{(1)}$ is an $n_1 \times J$ weight matrix, $\boldsymbol{b}^{(1)}$ is the bias (or the intercept), and $g:\mathbb{R}^{n_1} \rightarrow \mathbb{R}^{n_1} $ is some activation function that transforms the resulting linear combination \citep{ESL}. The vector $\boldsymbol{v}^{(1)}$ is $n_{1}$-dimensional and becomes the input to the next layer i.e., it takes the place of the $\boldsymbol{x}$ in the proceeding layer.

Observe that the classic neural network framework only permits the vectors (of the $N$ observations) $\{\boldsymbol{x}_{1}, \boldsymbol{x}_{2}, ...,$ $\boldsymbol{x}_{N}\}$ to contain elements that are finite scalar values. We now consider the case when $\boldsymbol{x}_{\ell}: \ell \in \{1, ...,N\}$ can be a combination of functional and scalar inputs. In this scenario, the input space takes the following form:
\begin{align*}
    \text{input}_\ell = \{x_{1}(t), x_{2}(t), ..., x_{K}(t), z_{1}, z_{2}, ..., z_{J}\},
\end{align*}
where $K$ and $J$ are the number of functional and scalar covariates, respectively. This set is unique for each of the $N$ observations. With this generalization, the $i$-th neuron of the first hidden layer corresponding to each of the $\ell$ observations takes the form \citep{thind2020deep}:
\begin{align*}
    v_i^{(1)} = g\left(\sum_{k = 1}^{K}\int_{\mathcal T_{k}} \beta_{ik}(t)x_{k}(t)dt + \sum_{j = 1}^{J}w_{ij}^{(1)}z_{j} + b_i^{(1)}\right),
\end{align*}
where $\beta(t)$ is the weight on the functional covariate; this is of a functional form because each of the $k$ functional inputs must be weighted at every point along their domains, $\mathcal{T}_{k}$. In order to estimate $\beta(t)$, it is rewritten as a linear combination of basis functions:
\begin{align}
\label{eq1and2}
    v_i^{(1)} &= g\left(\sum_{k = 1}^{K}\int_{\mathcal T_{k}} \sum_{m = 1}^{M_k}c_{ikm}\phi_{ikm}(t)x_{k}(t)dt + \sum_{j = 1}^{J}w^{(1)}_{ij}z_{j} + b^{(1)}_i\right)\\
    &= g\left(\sum_{k = 1}^{K}\sum_{m = 1}^{M_k}c_{ikm}\int_{\mathcal T_{k}} \phi_{ikm}(t)x_{k}(t)dt + \sum_{j = 1}^{J}w^{(1)}_{ij}z_{j} + b^{(1)}_i\right).
\end{align}
In \hyperref[eq1and2]{Equation (1)}, $\beta_{ik}(t)$ is approximated by $\sum_{m = 1}^{M_k}c_{ikm}\phi_{ikm}(t)$ where $\boldsymbol{\phi_{ik}(t)}$ is the set of basis functions and $\boldsymbol{c_{ik}}$ is the set of basis coefficients to be estimated by the functional neural network; in \hyperref[eq1and2]{Equation (2)}, the integral and sum are swapped and the term $\int_{\mathcal T_{k}} \phi_{ikm}(t)x_{k}(t)dt$ can be approximated using any of the usual approximation methods such as Simpson's rule \citep{Suli03}. Note that $x_{k}(t)$ is defined by its own set of basis functions.

A by-product of this method is the set of functional weights, $\beta(t)$, as represented by their basis expansions. These weights differ in comparison to the usual weights (found in conventional neural networks) in that they can be easily visualized over the corresponding continuum. This visualization illuminates the underlying relationship between the functional covariate and the scalar response. Moreover, passing in information in this functional form preserves the autocorrelation structure associated with the data. Due to the random initializations in the conventional neural network, these properties of the data become difficult to maintain if passed in discretely. In the canonical cases where we have more than one neuron, the average of the functional weights $\hat{\beta}_{k}(t) = \sum_{i=1}^{n_1}\hat{\beta}_{ik}(t)/{n_1}$, is used as the output.

This formulation of the neural network was shown \citep{thind2020deep} to be a universal approximator just as conventional neural networks are \citep{cybenko1989approximation}. While the details are omitted, the gist of the proof was to show that this form of the neuron, once simplified, held the same properties as the usual neural network.

\section[Fitting, Prediction, and Visualization]{Fitting, prediction, and visualization} \label{sec:fit}

\subsection{Data description}

Throughout this paper, we will focus on three main data sets: the \code{tecator} data set, the \code{gasoline} data set and the \code{gait} data set. The classic \code{tecator} data from the \pkg{fda.usc} package provides measurements of the near infrared absorbance spectrum and the moisture (water), fat and protein contents of 215 meat samples. Samples composed of different fat, water and protein contents may behave inconsistently in incident radiation absorption, which can be measured by absorbance spectroscopy. The data were recorded on a tecator infratec food and feed analyzer with wavelength range from 850 nm to 1050 nm using the near infrared transmission (NIT) principle. This data set consists of a list named \code{absorp.fdata} and a simple data frame labelled with \code{y}. The list \code{absorp.fdata} includes the matrix \code{data} summarizing a 100 channel spectrum of absorbance of each meat sample, where absorbance is $-\log_{10}$ of the transmittance determined by the spectrometer, and the vector \code{argvals} which contains the value of the 100 discretized channels from 850 nm to 1050 nm. The data frame \code{y} lays out the contents of the fat, water and protein of the 215 meat samples that are determined by analytic chemistry and measured in percent. This data has been applied with the goal of classifying the fat content levels of the meat samples with the functional covariate of the near infrared absorbance spectrum and the scalar covariate of the water content.

Secondly, we consider the \code{gasoline} data set sourced from the \pkg{refund} package \citep{refund}. This data set contains the near infrared reflectance (NIR) spectra and the specified octane numbers of 60 gasoline samples. For each gasoline sample,  401 NIR spectra were measured at different wavelengths, from 900 nm to 1700 nm in 2-nm intervals, and recorded using diffuse reflectance as $\log(1/\text{reflectance})$. As a simple data frame, the \code{gasoline} data consists of a vector containing the octane levels for each of the 60 collected samples, and a $60 \times 401$ matrix regarding the details of NIR measurements.  This data set has been used in examples with the aim of determining the octane number, a scalar value, of gasoline based on the functional predictor of the NIR measurements. Studies in past years \citep{gasoline_prediction, gasoline_determination} have supported the concept that a relationship exists between the chemical structure and the fuel-performance property of octane, while NIR spectroscopy is a popular method for simultaneous chemical analysis. Therefore, it has been implied that the properties of gasoline with different octane levels can be reflected by different NIR spectral features.

Finally, the examples given in this paper also make use of the \code{gait} data set obtained from the \pkg{fda} package. This data catalogs the hip and knee angles measured in degree through a twenty-point gait cycle for 39 boys. It is in the form of an array of dimension $20 \times 39 \times 2$, indicating the 20 evenly-spaced standardized gait times (from 0.025 to 0.975), the 39 subjects of observation, and the two gait variables Hip Angle and Knee Angle, respectively. It is unsurprisingly apparent that hip rotation has a regular association with knee movement in a normal walk. Therefore, in our example, we consider using hip movement as a functional covariate to make a prediction for the functional response knee angle.

\subsection{Pre-processing}

The \pkg{FuncNN} package allows two types of inputs of data; data can be passed in raw or pre-processed. As with most functional data analysis coding, pre-processing is required to approximate the raw data $x(t)$, using basis expansions. However, this can be tedious and ultimately, a barrier for anyone who is not familiar with the required procedures. The \pkg{FuncNN} package provides a remedy by letting novice users input their data without the heavy lifting of converting it into its functional form while also granting the opportunity for further customization for users who require a more specific or specialized pre-processing. In the case where the data is passed in raw, the \pkg{FuncNN} package will do a simple pre-processing using a Fourier basis expansion with 31 terms. While this is an average-case compromise that minimizes initial effort, the alternative approach of pre-processing allows for greater flexibility in the development of $x(t)$.

Since the functional observations can be passed in two different ways, they can be one of two object types. In the raw case, the functional covariates are passed in as a $K$-dimensional list where each element of the list is an $N \times p$ \fct{data.frame} containing $p$ measurements over the domain for each of the $N$ subjects.
\begin{CodeChunk}
\begin{CodeInput}
R>  func_cov_list = list(func_cov_1, func_cov_2, ..., func_cov_K)
\end{CodeInput}
\end{CodeChunk}
The scalar covariates can be passed in similar to most predictive functions i.e., as an $N \times J$ matrix containing information on the $J$ scalar variables for each of the $N$ observations.

If pre-processing is done beforehand, then the object being passed in must be a tensor. In \proglang{R}, the tensor-type object exists as an \fct{array}. The dimensionality of the tensor will be $M_{k} \times N \times K$ where each row corresponds to the estimated coefficient when the basis expansion was made, each column is an individual observation, and each ``slice'' corresponds to one of the $K$ functional covariates. Note that scaling is handled internally by the \fct{fnn.fit} function. The response can be passed in as a vector of length $N$.

 While the focus here is on scalar responses, the \pkg{FuncNN} package can handle a version of functional responses; this version entails a basis expansion of the response curves from which the basis coefficients are extracted and passed in as a matrix into the model function. The model will then attempt to predict these coefficients. More details are provided later in the article.

\subsection{Classification}

In this example, we will focus on the \code{tecator} data set. The response will be the classification of the fat content of the meat samples as ``high'' or ``low'', denoted by 1 and 0, respectively. The threshold is 25 percent i.e., if the fat content of a sample is greater than 25, then we designate the response associated with that sample as 1:
\begin{CodeChunk}
\begin{CodeInput}
R> tecator_resp = as.factor(ifelse(tecator$y$Fat > 25, 1, 0))
\end{CodeInput}
\end{CodeChunk}
We use the water content of the meat samples as a scalar covariate; as alluded to earlier, this will be stored in a \fct{data.frame} object.
\begin{CodeChunk}
\begin{CodeInput}
R> tecator_scalar = data.frame(water = tecator$y$Water)
\end{CodeInput}
\end{CodeChunk}
Since this is a prediction problem, we split the data into a training and test set; a random sample of 75\% of the data will be used to build the model and evaluation is performed on the rest. We will let the modelling function handle the pre-processing for this example and therefore, the object type to be passed in must be a list which can be generated as follows:
\begin{CodeChunk}
\begin{CodeInput}
R> func_covs_train = list(train_x)
R> func_covs_test = list(test_x)
\end{CodeInput}
\end{CodeChunk}
where \texttt{func\_covs\_train} and \texttt{func\_covs\_test} are the functional covariate matrices for the training and test sets, respectively (in this example, there is just one functional covariate). Finally, we can fit the model:
\begin{CodeChunk}
\begin{CodeInput}
R> fit_class = fnn.fit(resp = train_y,
+                      func_cov = func_covs_train,
+                      scalar_cov = scalar_train,
+                      domain_range = list(c(850, 1050)),
+                      raw_data = T)
\end{CodeInput}
\begin{scriptsize}
\begin{CodeOutput}
[1] "Evaluating Integrals:"
  |++++++++++++++++++++++++++++++++++++++++++++++++++| 10
Model
_______________________________________________________________________________________________________
Layer (type)                                  Output Shape                             Param #
=======================================================================================================
dense (Dense)                                 (None, 64)                               576
_______________________________________________________________________________________________________
dense_1 (Dense)                               (None, 64)                               4160
_______________________________________________________________________________________________________
dense_2 (Dense)                               (None, 2)                                130
=======================================================================================================
Total params: 4,866
Trainable params: 4,866
Non-trainable params: 0
_______________________________________________________________________________________________________

\end{CodeOutput}
\end{scriptsize}
\end{CodeChunk}
The first item printed refers to the integral approximations that take place as shown in \hyperref[sec:bg]{Section 2}; a progress bar is printed indicating the proportion of work completed in this phase. The training error plot for this model is in \hyperref[fig:ClassTec]{Figure 1} -- note that this output is a \fct{ggplot} \citep{ggplot2} object; this is the same type of object you would extract from the \pkg{keras} package. As with any Keras model, you can observe the total number of parameters of the model in the display (in this case, 4886); this printing of information can be muted by setting \texttt{print\_info} to \code{FALSE}. There are a number of hyperparameters that will be discussed later in the article; in this simple example, we stick to the defaults. The only additional specifications required in the model are to indicate that raw data is being passed in (the default is set to \code{FALSE}) and the range of the domain. This simple syntax removes the steep learning curve that comes with functional methods in some of the other packages discussed earlier. The output contains a Keras model object as well the generated functional observations (if the raw data was passed in), parameter information, and error rates over the training iterations. Additional information about the output object can be found in the \proglang{R} documentation for the \pkg{FuncNN} package.
\begin{figure}[h]
  \centering
  \includegraphics[height = 14em]{classRespError.pdf}
  \label{fig:ClassTec}
  \caption{The iterative error plot over the training process as measured by mean squared error for the \code{tecator} data set.}
\end{figure}
We now have a fitted model to make predictions with. As with most predictive functions, when one uses \fct{fnn.predict}, the fitted model is passed in along with the ``new data'' e.g., the \texttt{func\_covs\_test} object from before (along with the scalar counterpart).
\begin{CodeChunk}
\begin{CodeInput}
R> predict_class = fnn.predict(fit_class,
+                              func_cov = func_covs_test,
+                              scalar_cov = scalar_test,
+                              domain_range = list(c(850, 1050)),
+                              raw_data = T)
\end{CodeInput}
\end{CodeChunk}
The syntax is similar again. The function will automatically recognize that this is a classification problem and output class probabilities (the sum of each row will be 1). We can round these probabilities to get classifications and plot the confusion matrix (using the \pkg{caret} package \citep{caret}); this is showcased in the following code chunk:
\begin{CodeChunk}
\begin{CodeInput}
R> caret::confusionMatrix(as.factor(rounded_preds), as.factor(test_y))
\end{CodeInput}
\begin{CodeOutput}
Confusion Matrix and Statistics

          Reference
Prediction  0  1
         0 40  0
         1  1 13

               Accuracy : 0.9815
                 9
    No Information Rate : 0.7593
    P-Value [Acc > NIR] : 6.299e-06

                  Kappa : 0.9506

 Mcnemar's Test P-Value : 1

            Sensitivity : 0.9756
            Specificity : 1.0000
         Pos Pred Value : 1.0000
         Neg Pred Value : 0.9286
\end{CodeOutput}
\end{CodeChunk}
We can also visualize the relationship between the functional covariates and the scalar response by way of the functional weights using the \fct{fnn.fnc} function. The syntax is fairly straight-forward:
\begin{CodeChunk}
\begin{CodeInput}
R> fnc_tec = fnn.fnc(fit_class, domain_range = list(c(850, 1050)))
\end{CodeInput}
\end{CodeChunk}
As a point of interest, the \textit{fnc} part of the \fct{fnn.fnc} function stands for functional neural coefficient; this is legacy code naming convention but as a reference, anytime this is mentioned, it refers to the functional weights of the model. For this function, we only need to pass in the model along with the domain. The output will be the effect of the functional weight on the response over the continuum as estimated by the functional neural network; these can be made sense of at times, however, contextual information is required. We do hazard that because of the plethora of other parameters in the network, it can be difficult to interpret these parameters -- these interpretations should be considered carefully on a case-by-case basis. In this example, we observe that there seems to be two primary spikes over the continuum. The resulting functional weight from this model is given in \hyperref[fig:fnc_tec]{Figure 2}.
\begin{figure}[h]
  \centering
  \includegraphics[height = 12em]{fnc_tec.pdf}
  \label{fig:fnc_tec}
  \caption{The functional weight estimated through the functional neural network for the \code{tecator} data set. We observe two spikes. We also note that the magnitude of the effect depends on the scale of both the functional data and the functional weight.}
\end{figure}

\subsection{Regression}

We now consider an example of a regression problem; we will investigate the relationship between the near-infrared reflectance spectra (functional covariate) and and octane values (scalar response) of 60 gasoline observations in the \code{gasoline} data set. In this example, we will process the raw data beforehand and then pass it into \fct{fnn.fit}; we will also use multiple functional covariates by taking the derivatives of the functional data estimated using the raw data. In order to generate the functional observations, we use 9 Fourier basis functions. The \fct{Data2fd} function from the \pkg{fda.usc} package will allow us to create these functions with the following code:
\begin{CodeChunk}
\begin{CodeInput}
R> nbasis = 9
R> spline_basis = create.fourier.basis(c(900, 1700), nbasis)
R> gasoline_fd = Data2fd(timepts, t(gasoline[,-1]), spline_basis)
R> gasoline_deriv1 = deriv.fd(gasoline_fd)
R> gasoline_deriv2 = deriv.fd(gasoline_deriv1)
\end{CodeInput}
\end{CodeChunk}
where \texttt{gasoline\_fd} is the functional data object converted from the functional predictor. As alluded to earlier, when the data is pre-processed manually out of the function, we have to pass it in as a tensor object i.e., \texttt{arrays} in \proglang{R}. We can develop the array with the following code:
\begin{CodeChunk}
\begin{CodeInput}
R> gasoline_data = array(dim = c(nbasis, 60, 3))
R> gasoline_data[,,1] = gasoline_fd$coefs
R> gasoline_data[,,2] = gasoline_deriv1$coefs
R> gasoline_data[,,3] = gasoline_deriv2$coefs
\end{CodeInput}
\end{CodeChunk}

We now fit the model using a functional weight defined with five basis functions. In this initial release, we allow users to use Fourier and B-spline basis functions for the functional weights. Note that we specified the learning rate and the number of epochs in this model as well, along with the number of layers -- these are just some of the numerous hyperparameters that can be adjusted in this function.
\begin{CodeChunk}
\begin{CodeInput}
R> gasoline_example <- fnn.fit(resp = train_y,
+                              func_cov = gasoline_data_train,
+                              scalar_cov = NULL,
+                              basis_choice = c("bspline"),
+                              num_basis = c(5),
+                              hidden_layers = 2,
+                              neurons_per_layer = c(64, 64),
+                              activations_in_layers = c("relu", "linear"),
+                              domain_range = list(c(900, 1700)),
+                              epochs = 300,
+                              learn_rate = 0.0001,
+                              early_stopping = T)
\end{CodeInput}
\begin{scriptsize}
\begin{CodeOutput}
[1] "Warning: You only specified basis information for one functional covariate --
it will be repeated for all functional covariates"
[1] "Evaluating Integrals:"
  |++++++++++++++++++++++++++++++++++++++++++++++++++| 10
  |++++++++++++++++++++++++++++++++++++++++++++++++++| 10
  |++++++++++++++++++++++++++++++++++++++++++++++++++| 10
Model
_______________________________________________________________________________________________________
Layer (type)                                  Output Shape                             Param #
=======================================================================================================
dense (Dense)                                 (None, 64)                               1024
_______________________________________________________________________________________________________
dense_1 (Dense)                               (None, 64)                               4160
_______________________________________________________________________________________________________
dense_2 (Dense)                               (None, 1)                                65
=======================================================================================================
Total params: 5,249
Trainable params: 5,249
Non-trainable params: 0
_______________________________________________________________________________________________________
\end{CodeOutput}
\end{scriptsize}
\end{CodeChunk}
Observe the warning present in the output -- the \pkg{FuncNN} package has many stop checks built to provide clear information to the user regarding errors and warnings. In this case, we had 3 functional covariates but only specified information for one functional weight - i.e., we specified the functional weight to be a B-spline expansion of five terms.  To make up for the lack of information, \fct{fnn.fit} will just repeat this same setup for all of the inputted functional covariates.

Again, we provide the Keras model information. We observe that there were 5249 parameters being trained during the model building process. The error plot is given in \hyperref[fig:RegGas]{Figure 3} -- observe that the \texttt{early\_stopping} parameter was triggered in this case so the plot does not extend to the specified 300 epochs.  More information on this parameter is provided later in the article.
\begin{figure}[h]
  \centering
  \includegraphics[height = 14em]{RegGasError.pdf}
  \label{fig:RegGas}
  \caption{The iterative error plot over the training process as measured by mean squared error for the \code{gasoline} data set.}
\end{figure}
Predictions are handled using the same function, \fct{fnn.predict}; again, the only difference will be that the output will be a vector of values as opposed to a matrix containing class probabilities.

\subsection{Functional responses}

To demonstrate functional responses, we will predict knee movement using hip movement with the information presented in the \code{gait} data set. While we present a straightforward approach to functional response prediction, we will update the package with a more refined and sophisticated approach as we continue to develop such methodology.  The approach used in the following example boils down to predicting the coefficients of the functional data object corresponding to the response. To begin, we read in the data and generate our functional observations:
\begin{CodeChunk}
\begin{CodeInput}
R> hipbasis13 = create.fourier.basis(c(0,1), 13)
R> kneebasis11 = create.fourier.basis(c(0,1), 11)
R> timepts = as.numeric(rownames(gait))
R> hip_fd = Data2fd(timepts, gait[,,1], hipbasis13)
R> knee_fd = Data2fd(timepts, gait[,,2], kneebasis11)
\end{CodeInput}
\end{CodeChunk}
In this example, we use 13 and 11 basis functions to generate the hip and knee observations, respectively. The pre-processing is done in a manner similar to that of the regression case above. A notable point is that the response will now be a $N \times M_{\text{resp}}$ matrix object where $N$ is the number of functional observations and $M_{\text{resp}}$ is the number of basis functions used to define these observations -- the values in the matrix correspond to the estimated basis coefficients (in this example, we have 11 per observation).

We now fit the model using four layers containing 64 neurons each with \textit{relu} \citep{hahnloser2000digital} activation function. The learning rate was selected after a small grid search.
\begin{CodeChunk}
\begin{small}
\begin{CodeInput}
R> gait_fit <- fnn.fit(resp = resp_train,
+                      func_cov = data_train,
+                      hidden_layers = 3,
+                      activations_in_layers = c("relu", "relu", "relu"),
+                      neurons_per_layer = c(128, 128, 32),
+                      epochs = 300,
+                      learn_rate = 0.0007)
\end{CodeInput}
\end{small}
\begin{scriptsize}
\begin{CodeOutput}
[1] "Evaluating Integrals:"
  |++++++++++++++++++++++++++++++++++++++++++++++++++| 10
Model
_______________________________________________________________________________________________________
Layer (type)                                  Output Shape                             Param #
=======================================================================================================
dense (Dense)                                 (None, 128)                              1024
_______________________________________________________________________________________________________
dense_1 (Dense)                               (None, 128)                              16512
_______________________________________________________________________________________________________
dense_2 (Dense)                               (None, 32)                               4128
_______________________________________________________________________________________________________
dense_3 (Dense)                               (None, 11)                               363
=======================================================================================================
Total params: 22,027
Trainable params: 22,027
Non-trainable params: 0
_______________________________________________________________________________________________________
\end{CodeOutput}
\end{scriptsize}
\end{CodeChunk}
\begin{figure}[h]
  \centering
  \includegraphics[height = 14em]{funcRespError.pdf}
  \label{fig:funcRespError}
  \caption{The iterative error plot over the training process as measured by mean squared error for the \code{gait} data set.}
\end{figure}
The error plot corresponding to this model is given in \hyperref[fig:funcRespError]{Figure 4}.  This model was, thus far, the most parameter heavy of the examples with a total of 22,027. Predictions are made in a similar manner as before; the output object will be a matrix with a number of columns equal to that of $M_{\text{resp}}$ and a row dimensionality the same as the number of functional observations in the test set.
\begin{CodeChunk}
\begin{CodeInput}
R> predictions = fnn.predict(model = gait_fit,
+                            func_cov = data_test)
\end{CodeInput}
\end{CodeChunk}
 To visualize the results, the \fct{fnn.plot} function can be used which will output the evaluations of the functional response prediction over the domain. The syntax consists of specifying the prediction object, the domain, a step size which determines how finely evaluations are made, and the type of basis function to be used for the plot.
\begin{CodeChunk}
\begin{CodeInput}
R> gait_func_pred = fnn.plot(predictions,
+                            domain_range = c(0, 1),
+                            step_size = 0.05,
+                            Basis_Type = "fourier")
\end{CodeInput}
\end{CodeChunk}
Using these predictions, we can compare our predicted curve to the true functional response; \hyperref[fig:funcResp]{Figure 5} shows one such comparison.

\begin{figure}[h]
  \centering
  \includegraphics[height = 12em]{funcRespPlot.pdf}
  \label{fig:funcResp}
  \caption{A comparison of a knee angle prediction $\hat{y}(t)$ over a 1 second interval (functional response) with the observed movement, $y(t)$.}
\end{figure}

\section[Tuning and CV]{Model improvement tools} \label{sec:cv}

\subsection{Hyperparameters}

Thus far, we have generated models largely using the default settings of the \pkg{FuncNN} package; however, there is ample opportunity to adjust these models so that they are best suited for a particular context. These adjustments come by way of toying with the hyperparameter options available to us in the modelling process.
\begin{center}
\setlength{\tabcolsep}{15pt}
\setlength{\columnseprule}{0.2pt}
\scalebox{0.65}{
\label{table:one}
 \begin{tabular}{||c | c | c ||}
 \hline
 \texttt{Parameter} & \texttt{Type} & \texttt{Details} \\ [1ex]
 \hline\hline
  $\beta(t)$ & Estimated & Coefficient function found by the FNN. \\ [1ex]
  \hline\hline
  $w$ & Estimated & The scalar covariate weights. \\ [1ex]
 \hline\hline
  $b$ & Estimated & The intercept in each neuron. \\ [1ex]
 \hline\hline
  Number of lyers & Hyperparameter & The depth of the FNN. \\ [1ex]
 \hline\hline
  Neurons per layer & Hyperparameter  & Number of neurons in each layer of the FNN. \\ [1ex]
 \hline\hline
  Learn rate & Hyperparameter & The learning rate of the FNN. \\ [1ex]
 \hline\hline
  Decay rate & Hyperparameter & A weight on the learning process across training iterations for the FNN. \\ [1ex]
  \hline\hline
  Validation split & Hyperparameter & The split of training set during learning process. \\ [1ex]
  \hline\hline
  Functional weight basis & Hyperparameter & The size of $M$ for the estimation of $\beta(t)$. \\ [1ex]
  \hline\hline
  Training iterations & Hyperparameter & The number of learning iterations. \\ [1ex]
  \hline\hline
  Batch size & Hyperparameter & Subset of data per pass of the FNN. \\ [1ex]
  \hline\hline
  Activations & Hyperparameter & The choice of $g(\cdot)$ for each layer. \\ [1ex]
  \hline\hline
  Early stopping & Hyperparameter & Stops the model building process if no improvement in error. \\ [1ex]
  \hline\hline
  Dropout & Hyperparameter & Randomly drops some specified percentage of neurons from one layer to the next. \\ [1ex]
  \hline\hline
\end{tabular}}
\captionof{table}{A list of the parameters in the network.}
\end{center}

Some parameters, such as the ones seen explicitly in \hyperref[eq1and2]{Equation 1}, are estimated through gradient descent - i.e., the "learning" process of the model results in the final values. Others, such as the number of hidden layers and the neurons within each of these layers, are adjusted for by the user. For example, as demonstrated earlier in the article, the \texttt{early\_stopping} option halts the learning process when significant decreases in error have not been observed for some number of training iterations -- this number, known as the patience parameter, is also a hyperparameter. Another example is that of the learning rate, $\gamma$, and the decay rate, which both govern how quickly we move in the direction of the gradient. The complete list of hyperparameters along with descriptions is provided in \hyperref[table:one]{Table 1}.

\subsection{Cross-validation}

A first step in choosing parameter values in any modelling process is to find a reliable measuring stick to assess how a model performs. One approach to solving this problem is cross-validation. The general definition for a k-fold cross-validation error is \vspace{-.2cm} $$\text{MSPE} = \sum_{k=1}^K \sum_{l \in S_k}\left(\hat{y}_{l}^{(-k)} - y_{l}\right)^2/\left(|S_k|K\right) \vspace{-.2cm}$$  where $\{S_k\}_{k=1}^K$ is a partition of the data set, $|S_k|$ denotes cardinality, and $\hat{y}_{l}^{(-k)}, l \in S_k,$ is the predicted value for $y_l$ obtained by training the functional neural network using data points with indices not contained in $S_k$.  Choosing to measure error in this way ensures that our measurement is computed using data that was not used to train the model, reducing the bias relative to other estimations of test error.

This paradigm is at the core of \fct{fnn.cv}, the package's cross-validation function. Much of the syntax overlaps with the \fct{fnn.fit} function. We demonstrate the cross-validation function using the \code{gasoline} data set. Instead of splitting the data into test and training sets, we can pass in the entire data set -- the cross-validation function will take care of this internally. The \texttt{nfolds} option determines the number of subsets in our partition of the full data set -- this is the only syntax difference between the \fct{fnn.fit} and \fct{fnn.cv} functions.
\begin{CodeChunk}
\begin{CodeInput}
R> gasoline_cv <- fnn.cv(nfolds = 10,
+                        resp = octane,
+                        func_cov = gasoline_data,
+                        scalar_cov = NULL,
+                        basis_choice = c("bspline", "bspline", "bspline"),
+                        num_basis = c(5, 5, 5),
+                        hidden_layers = 2,
+                        neurons_per_layer = c(64, 64),
+                        activations_in_layers = c("relu", "linear"),
+                        domain_range = list(c(900, 1700),
+                                           c(900, 1700),
+                                           c(900, 1700)),
+                        epochs = 300,
+                        learn_rate = 0.0001,
+                        early_stopping = T)
\end{CodeInput}
\end{CodeChunk}
While the function is running, the number of completed folds will be displayed and updated, for example:
\begin{CodeChunk}
\begin{CodeOutput}
[1] "Folds Done: 1"
[1] "Folds Done: 2"
...
\end{CodeOutput}
\end{CodeChunk}
The output will contain the overall cross-validated error as well as the errors corresponding to each fold. The indices for each fold split will also be available for users if they choose to reproduce the function results manually. In this example, a 10-fold cross-validation was done and the MSPE was 0.0735. We look to improve on this in the next section.

\subsection{Tuning}

Having honed in on a more robust measure of error, we can begin to outline the tuning approach, which consists of a classic grid search to develop testable combinations of hyperparameters. Algorithm 1 below details the tuning process used in \pkg{FuncNN}.
\IncMargin{1.5em}
\begin{algorithm}
\SetAlgoNoLine
\DontPrintSemicolon
\newcommand{\hrulealg}[0]{\vspace{2mm} \hrule \vspace{1mm}}
\SetKwBlock{Loop}{For}{End}
\linespread{1.15}\selectfont

\KwIn{A subset of all possible values for each of the hyperparameters of interest, including: number of hidden layers, number of neurons, number of training iterations, percentage of split, patience, learning rate, number of basis functions, and activation function}
\KwOut {The optimal set of hyperparameters ($\eta$) over all combinations of the elements in \textbf{Input}}
\hrulealg
\nl Input the grid, along with the functional and scalar observations, and set the non-tuning hyperparameters, e.g., type of basis functions, number of folds ($k$) for cross-validation, rate of decay, etc.\\
\nl Generate all possible combinations of hyperparameters, denoted $\eta_{1}, \eta_{2}, ..., \eta_{n}$, where $n$ is the total number of combinations \\
\Loop (each hyperparameter combination $\eta_{i}, i = 1, ...., n$){
\nl Construct the functional neural network with $\eta_{i}$ \\
\nl Train the designed functional neural network\\
\nl Calculate the $k$-fold cross-validation error MSPE($\eta_{i}$)
}
\nl Return $\eta = \{\eta_{k}: $ MSPE($\eta_{k}$) $ \leq $ MSPE($\eta_{i}$)$ \text{ for all } i\}$

\caption{Tuning (Hyperparameter optimization)}
\end{algorithm}
\DecMargin{1.5em}

The \pkg{FuncNN} package makes this intuitive and easy. There is no automated pre-processing for the tuning function, \fct{fnn.tune}; this decision was made due to efficiency concerns but will be remedied for in the future. The syntax is as follows:
\begin{CodeChunk}
\begin{CodeOutput}
fnn.tune(tune_list,
         resp,
         func_cov,
         scalar_cov = NULL,
         basis_choice,
         domain_range,
         batch_size = 32,
         decay_rate = 0,
         nfolds = 5,
         cores = 4,
         raw_data = F)
\end{CodeOutput}
\end{CodeChunk}
Some of these have already been presented before. The ones to note are the \texttt{tune\_list} and \texttt{cores} parameters. The latter is an efficiency parameter that allows for parallelization. This is handled internally by the dependency \pkg{future} \citep{future}. The former must be a list object that contains the grid of combinations to be tested. An example of what this list might look like is:
\begin{CodeChunk}
\begin{CodeInput}
R> tune_list_gasoline = list(num_hidden_layers = c(2),
+                            neurons = c(32, 64),
+                            epochs = c(250),
+                            val_split = c(0.2),
+                            patience = c(15),
+                            learn_rate = c(seq(0.0001, 0.001,
+                                           length.out = 5)),
+                            num_basis = c(5, 7, 9),
+                            activation_choice = c("relu", "sigmoid"))
\end{CodeInput}
\end{CodeChunk}
This object is not processed as obviously as it may seem. We assign each of the hidden layer choices (in this case, just the one choice of 2 hidden layers) all combinations of neurons and activation functions. This is exemplified below:
\begin{CodeChunk}
\begin{CodeOutput}
   L1_Act L2_Act FW_1 FW_2 FW_3 L1_N L2_N Epochs ValSplit Patience LearnRate
1    relu   relu    5    5    5   32   32    250      0.2       15  0.000100
2    relu   relu    5    5    7   32   64    250      0.2       15  0.000550
3    relu   relu    5    5    5   32   64    250      0.2       15  0.000550
4    relu   relu    5    5    5   32   64    250      0.2       15  0.001000
5    relu   relu    5    5    5   32   64    250      0.2       15  0.000100
6    relu   relu    5    5    7   32   32    250      0.2       15  0.000325
7    relu   relu    5    5    5   32   32    250      0.2       15  0.000325
8    relu   relu    5    5    5   64   32    250      0.2       15  0.001000
9    relu   relu    5    5    5   32   32    250      0.2       15  0.000775
10   relu   relu    5    5    5   64   32    250      0.2       15  0.000100
11   relu   relu    5    5    9   32   32    250      0.2       15  0.000550
12   relu   relu    5    5    7   32   32    250      0.2       15  0.000550
13   relu   relu    5    5    5   32   32    250      0.2       15  0.000550
14   relu   relu    5    5    5   32   32    250      0.2       15  0.001000
15   relu   relu    5    5    5   64   32    250      0.2       15  0.000325
\end{CodeOutput}
\end{CodeChunk}
Observe that we are cycling through all of the possible combinations of neuron numbers, activation functions, and functional weight basis counts from the list. We did not need to specify the number of neurons for each layer separately. While this is less obvious of an approach than allowing the user to set the grid for each layer, it is much more efficient when one considers that they may want to be tuning over many layers. For example, tuning over 10 hidden layers in the traditional approach would require a list object that contains over 30 elements, whereas in this case, the length of the list remains the same no matter how many layers you are attempting to tune for.

Having set up the tuning list, we can now consider the code required to run the tuning function:
\begin{CodeChunk}
\begin{CodeInput}
R> gasoline_tuned = fnn.tune(tune_list = tune_list_gasoline,
+                            resp = octane,
+                            func_cov = gasoline_data,
+                            basis_choice = c("fourier", "fourier",
+                                             "fourier"),
+                            domain_range = list(c(900, 1700),
+                                                c(900, 1700),
+                                                c(900, 1700)),
+                            nfolds = 2)
\end{CodeInput}
\end{CodeChunk}
With respect to \texttt{nfolds}, we see that the tuning comparisons will be done with a 2-fold cross-validated error. Increasing this number, as expected, will increase the computational time of this function. You may tune for a multiple number of layers at once. In that case, the grid above is reproduced for each hidden layer. The output will be a list object containing the final grid (as seen above), the cross-validated MSPE values for every combination, the best from each choice of layers, and the overall best across all layers (along with the corresponding parameters).

While the functions runs, we took advantage of the \pkg{pbapply} package \citep{pbapply} to provide users with a progress bar.
\begin{CodeChunk}
\begin{CodeOutput}
|++++++++++++++++++++++++++++++++++++++++++++++++  | 9
\end{CodeOutput}
\end{CodeChunk}
This progress bar displays the approximate amount of time remaining until the tuning is finished; this information offers some obvious benefits to a user's quality of experience.

Our goal for this tuning (applied to the \code{gasoline} data set) was to significantly outperform the cross-validated error from the default settings presented before. After running the tuning function, the optimal parameters over the pre-defined grid were:
\begin{CodeChunk}
\begin{CodeInput}
R> gasoline_tuned$Parameters
\end{CodeInput}
\begin{CodeOutput}
$MSPE
[1] 0.002492664

$num_basis
[1] 7 9 9

$hidden_layers
[1] 2

$neurons_per_layer
[1] 32 32

$activations_in_layers
[1] "sigmoid" "relu"

$epochs
[1] 250

$val_split
[1] 0.2

$patience_param
[1] 15

$learn_rate
[1] 0.001
\end{CodeOutput}
\end{CodeChunk}

Using these parameter choices, we can run the cross-validation function again (with ten folds for the purposes of comparison under equivalent circumstances):
\begin{CodeChunk}
\begin{CodeInput}
R> gasoline_tuned_cv <- fnn.cv(nfolds = 10,
+                              resp = octane,
+                              func_cov = gasoline_data,
+                              scalar_cov = NULL,
+                              basis_choice = c("bspline", "bspline",
+                                               "bspline"),
+                              num_basis = c(7, 9, 9),
+                              hidden_layers = 2,
+                              neurons_per_layer = c(32, 32),
+                              activations_in_layers = c("sigmoid", "relu"),
+                              domain_range = list(c(900, 1700),
+                                                  c(900, 1700),
+                                                  c(900, 1700)),
+                              epochs = 250,
+                              learn_rate = 0.001,
+                              early_stopping = T)
\end{CodeInput}
\end{CodeChunk}
And the resulting cross-validated MSPE was 0.0043. The results are summarized in \hyperref[table:two]{Table 2}:
\begin{center}
\setlength{\tabcolsep}{40pt}
\setlength{\columnseprule}{0.4pt}
\scalebox{0.85}{
\label{table:two}
 \begin{tabular}{||c | c | c ||}
 \hline
 \texttt{Model} & \texttt{CV MSPE} & \texttt{Standard error} \\ [1ex]
 \hline\hline
  Default & 0.0735 & 0.0534 \\ [1ex]
  \hline\hline
  Tuned & 0.0043 & 0.00275 \\ [1ex]
 \hline
\end{tabular}}
\captionof{table}{Tuning vs. default model results.}
\end{center}
We observe a much smaller standard error on our tuned model, indicating a greater level of consistency with respect to the predictions. The high variance in the default model suggests that there is some propensity for that particular model to overfit the data; it seems that behaviour is largely contained in the tuned model.

\section[Conclusions]{Conclusion and future work} \label{sec:conc}

Functional data analysis is an emerging field where new and exciting research is being conducted through a different data paradigm than the usual multivariate lens; this paper has illustrated how the functions introduced in the \pkg{FuncNN} take advantage of this paradigm and allow users to generate useful models which apply deep learning to functional data.
Since \pkg{FuncNN} package is built on top of the Keras architecture, many of the numerous parameters available to users implementing Keras models are also available for the software introduced here.

Throughout the article, we presented a number of functions. This includes core functions such as those for model fitting (\fct{fnn.fit}) and predicting (\fct{fnn.predict}) but also additional convenience functions for easier validation of analysis (e.g., \fct{fnn.cv}, \fct{fnn.tune}). These functions were highlighted with the use of examples including those in the context of regression, classification, and functional responses.

A number of updates to the package have been scheduled including the introduction of more core Keras options. We also are working on a better parallelization of the underlying processes to help with efficiency. Lastly, while we presented one way of handling functional responses in this article, there is a novel extension that is being worked on -- this approach will also be available in future versions of \pkg{FuncNN}.

\section*{Acknowledgments}

We would like to thank Matthew Reyers, Meyappan Subbaiah, and Kevin Multani for their useful discussions during the development of the package.

redpajama_set_name: RedPajamaArXiv


text:
Q: Google Books API shows only 10 results. Want to iterate the startIndex so that it loops until all the results are shown function bookSearch() {
  var search = document.getElementById('search').value
  document.getElementById('results').innerHTML = ""
  console.log(search)
  var startIndex =

So I want to iterate the ajax call until it shows all the items and not just the 10. Can get 40 by using maxresults parameter. So the startIndex needs to change from 0 to 20 to 40 to 60 and so on after every iteration.
while (startIndex < 2000) {
  $.ajax({
    url: "https://www.googleapis.com/books/v1/volumes?q=" + search + "&startIndex=" + startIndex + "&maxResults=40",
    dataType: "json",

    success: function (data) {
      console.log(data)
      for (i = 0; i < data.items.length; i++) {
        results.innerHTML += "
" + data.items[i].volumeInfo.title + "
"
        results.innerHTML += "
" + data.items[i].volumeInfo.authors + "
"
        results.innerHTML += "
" + data.items[i].volumeInfo.publishedDate + "
"
      }
    },
    type: 'GET'
  });
}
}

document.getElementById('button').addEventListener('click', bookSearch, false)

A: You can try this. Count total_items until it reach more than 40 and loop the function to print the results:
// start

var startIndex=0;

// button clicked
$("#button").click(function(){
  $("#results").html('');
  var searchInput = $("#search").val();
  getBooks(searchInput)
})

// onclick function run
function getBooks(search) {
  RunApi(search, startIndex);
  $("#results img").remove();
}

// run function to get results if available
function RunApi(search, start){
  $.ajax({
    url:"https://www.googleapis.com/books/v1/volumes?q=" + search + "&maxResults=40&startIndex="+start,
    dataType: "json",

    success: function(data) {
      console.log(data)
      totalItems = data.totalItems;
      if(data.items){
        for(i=0; i<data.items.length; i++){
          if(data.items[i].volumeInfo){
            var itemNubmer = startIndex+i;
            results.innerHTML += "
"+itemNubmer+": " + data.items[i].volumeInfo.title + "
"
            // results.innerHTML += "
" + data.items[i].volumeInfo.authors + "
"
            // results.innerHTML += "
" + data.items[i].volumeInfo.publishedDate + "
"
          }

        }
      }
      // repeat the function
      if(totalItems > 40){
      startIndex+=40;
      RunApi(search, startIndex);
      }
    },
    type:'GET'
  });
}

redpajama_set_name: RedPajamaStackExchange


text:
2016 FIAT 500X
#4 out of 11 in 2016 Affordable Subcompact SUVs
2016 FIAT 500X Performance Review
Note: This performance review was created when the 2016 FIAT 500X was new.
Overall, reviewers find the 2016 Fiat 500X's performance to be satisfactory, but not particularly thrilling. They report that although the larger optional engine provides a bit more power than the base engine, it's noisy and unrefined. Test drivers say the standard six-speed manual transmission is easy-shifting, but can feel dull. They add that the available nine-speed automatic transmission can be slow to respond from a stop and has trouble finding the correct gear. Although reviewers agree that the Fiat 500X has sporty handling and is easy to maneuver, they wish its steering offered more feedback.
Dynamically, the 500X is about par for the subcompact SUV course." -- Consumer Guide
"My little black heart knows very few folks will opt for the base car. That's a big shame. With the 2.4 under the hood an the nine-speed automatic in place, the 500X is going to have a tough time keeping its head up against well-sorted hardware from Honda, Nissan, Mazda, and yes, even Chevrolet." -- Road and Track
"As we head north toward Malibu, we can already tell that the 500X feels like a different kind of Fiat, more substantial. It fills the lane. There's an upright driving position, and we feel confident cruising along at 70 miles per hour." -- Autoblog
"Spinning through the Westside and into the hills above Malibu in a front-wheel-drive X, I found the performance underwhelming. The engine strained under acceleration, even in sport mode, and took a long time to get up to freeway speed." -- Los Angeles Times
"Overall, the first impression is that it would be a competent companion to an enthusiast's sports car, though also a good recommendation for your non-enthusiast neighbor." -- Automobile Magazine
Acceleration and Power
The 2016 Fiat 500X comes with a turbocharged 1.4-liter four-cylinder engine that makes 160 horsepower and is mated to a six-speed manual transmission. A 2.4-liter four-cylinder engine that produces 180 horsepower is available and is paired with a nine-speed automatic transmission. According to the EPA, the base 2016 500X gets 25/34 mpg city/highway, which is about average for the class.
Test drivers say the 500X's base engine has adequate power for typical driving situations. Although the larger available engine produces a bit more power, auto writers complain that it's noisy and unrefined. According to some critics, the standard manual transmission can sometimes feel imprecise, but others report that it shifts easily. Critics are also disappointed in the optional nine-speed automatic transmission, which they say has trouble finding the correct gear.
"All other buyers get a 2.4-liter 4-cylinder paired with a 9-speed automatic transmission. The 2.4 produces 180 hp and 175 lb-ft of torque. While those figures are similar to the 1.4, the larger size gives the engine more natural torque at low speeds. Unfortunately, that positive is offset by the 2.4's coarse character and a transmission that's prone to searching for gears and sometimes delivering clunky shifts. It's too bad that FIAT doesn't offer the 1.4 in other models." -- AutoTrader
For starters, you get the same turbocharged 1.4-liter four-cylinder found in the devilish 500 Abarth. It makes good, brusque, Italian noises, and delivers almost 10 more lb-ft of torque than its larger-displacement counterpart thanks to 22 psi of boost. Yeah, it makes do with 20 fewer horses, but you won't care. It's the better engine." -- Road and Track
"We'd still rather have been in a Golf or similar on the challenging roads, and the Tigershark four's buzzy drone isn't exactly thrilling, even if it did deliver the power when we wanted it." -- Car and Driver
Although not a powerhouse, the 2.4L delivers snappy acceleration thanks to the 500X's light 3,000 pound curb weight." -- Left Lane News
"The base Pop model, sampled in a short loop around L.A., can't be recommended, even if you must have a manual gearbox. The less powerful turbo-four makes the 500X feel bigger, heavier, and more awkward, and when the turbo kicks in all you get is torque-steer. The manual gearbox feels loose and vague." -- Automobile Magazine
Handling and Braking
Reviewers say the 2016 Fiat 500X is nimble around corners. However, most test drivers agree that its steering feels vague and gives poor feedback. The 2016 500X has an available Dynamic Selector, which allows you to choose between three driving modes: Auto, Sport and Traction +. Automotive journalists agree that Auto mode is the most pleasant setting for the typical drive, as Sport mode makes the 500X's handling feel overly sensitive. They also note that models equipped with 18-inch wheels have a fairly harsh ride. Front-wheel drive is standard, and all-wheel drive is available. A few reviewers say the brakes work just fine, and others point out that even under hard braking, the 500X exhibits little nose dive.
We might wish for more steering feel, but there was good responsiveness and on-center weight in Sport mode. We worked the brakes pretty hard and they responded reliably and predictably-they never made us say, 'wow' but never caused a worry, either." -- Car and Driver
… there is minimal understeer, not much yaw, and an ability to rotate in the corners. It's not as kid-rally-racer radical as the Nissan Juke, but it's also not as harsh as the pricey Mini Countryman." -- Automobile Magazine
The steering is fairly quick and direct, though without a lot of road feel. Handling is well controlled and the vehicle leans little in turns. While it's more fun than the awkward 500L, it doesn't capture the water bug agility of the 500 model. The ride is a mixed bag, too. It's fairly supple with the base 16-inch wheels but becomes firm with the available 18s. If you live in the rust belt, try the 18s before you buy." -- AutoTrader
"The 500X was more than willing to climb up on curbs and to descend from them without clanging its wheels against the pavement, making maneuvering in tight city quarters very easy while offering much greater flexibility than other small softroaders its size. And that's where the 500X's most useful everyday utility lies -- being able to squeeze into tight spaces in cities with less than ideal road infrastructure and to maneuver at will without losing face or crunching something on its bottom." -- AutoWeek
Like a kid on a sugar high, the 500X just feels too high-strung in Sport mode, with a hyper-sensitive gas pedal and reluctant-to-shift gearbox combining for a jerky ride. Needless to say, we preferred the 500X's default driving mode, which is plenty responsive." -- Left Lane News
Calculate 2016 FIAT 500X Monthly Payment Which Cars You Can Afford?


text:
Categories Elizabethtown Area School DistrictFeaturedNewsSchoolSchool Board News
E-Town Schools' Food Sales Rise With Vendor
Author Dan Robrish Posted on Posted on November 29, 2018 November 28, 2018
The food service vendor for the Elizabethtown Area School District had a loss of more than $110,000 in revenue for the 2017-18 school year — its first year operating here — but food sales and revenue have increased so far this year, representatives of the vendor told the school board.
At their meeting on Tuesday, Nov. 27, school board members sampled items to be rolled out in coming months, including pancakes and sushi. After that, they listened to a presentation by Josh Bain, assistant manager of food service for vendor SFE, and Courtney Kolp, assistant general manager.
In June 2017, the board approved a contract with SFE (Southwest Foodservice Excellence), based in Scottsdale, Ariz. Previously, the district operated its own food service.
The factors contributing to last year's revenue loss included weather-related dismissals and closings ($28,174) and a fire in the high school/middle school kitchen ($10,726). Another $53,847 was lost on a la carte items, because of pricing and the fact that fries were no longer an a la carte item and had to be included in a meal price.
Also, because it was a new program, the district didn't want to raise prices and negatively impact perception, Bain noted. So instead of tier pricing, all meals were the same price. Also, the district forfeited an additional $17,759 by not adding a 10-cent increase called for by a government pricing tool. (The increase was added for this year.) And there have been adjustments for local tastes. Noting that, initially, some meals had a Southwest flavor, "we learned that maybe our Pennsylvania Dutch clientele is not so much into the spice," Bain said.
So far this year through mid-November, both breakfast and lunch sales continue an upward trend, and daily revenue has increased by $300, Bain said.
Kolp said that the grab-andgo breakfast carts added last spring to the middle school and this fall to the high school have been "wildly successful." Selling coffee at the high school has greatly increased breakfast a la carte sales, she added. Hot chocolate will be offered starting the week of Dec. 3, she said.
Kolp said that SFE will continue taste-testing with students and will attend upcoming PTO meetings at the elementary schools, since parents usually decide whether students eat in the cafeteria. Plans also call for offering the popular fruit slushes at the elementary schools and soft-serve frozen yogurt at the high school/middle school in January. There will be an educational farmer's market in the spring.
The presentation also included information on the online Nutrislice program, which offers nutritional information and online ordering, to be available first to faculty and staff.
In other business, the school board approved a contract with Market Street Sports to give White Family Dental naming rights for the football stadium. The contract will yield over $75,000 to the district over 10 years. The board also accepted a $5,000 donation from Jess Durham toward handrails in the stadium bleachers. The board also approved new drop-off and pickup times for two Mill Road Elementary bus runs. Business manager George Longridge outlined a schedule for the 2019-20 budget process: On Jan. 22, the board will vote to display a proposed preliminary budget; on Feb. 12, a preliminary budget will be adopted. On April 9, the administration will present a proposed final budget, and on May 28, the final budget will be voted on. The Act 1 index, which limits tax increases, will be 2.9 percent.
The approved personnel report included the hiring of athletic director William Templin. Also, Christel Pond is resigning as East High Elementary assistant principal effective Jan. 1. District spokesman Troy Portser said later that she was taking a position with a district in the Scranton area.


text:
package org.apache.http.protocol;

public interface HttpRequestHandler
{
  // Methods

  @com.francetelecom.rd.stubs.annotation.CallBack("handle")
  public void handle(org.apache.http.HttpRequest arg1, org.apache.http.HttpResponse arg2, HttpContext arg3) throws org.apache.http.HttpException, java.io.IOException;
}


The Nunchaku Coils by Uwell are made specifically for the Uwell Nunchaku Sub-Ohm Tank. Uwell introduces the Pro-FOCS Coil with the Plug-Pull technology for a outstanding flavor and vapor production.
Uwell Nunchaku Tank available here.


To be available at major retailers for $39.99.
Nicalis has announced that it will publish a physical edition of Wonder Boy: The Dragon's Trap for PlayStation 4 and Switch at major retailers across North America in Q1 2018 for $39.99.
Wonder Boy: The Dragon's Trap is currently available digitally for PlayStation 4, Xbox One, Switch, PC, Mac, and Linux.
The Switch and PS4 versions of Wonder Boy: The Dragon's Trap are presented in widescreen HD, with enhanced interface functions, a new playable character (Wonder Girl) and the option to toggle between the all-new hand-drawn visuals and the original graphics.


text:
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/analytics/admin/v1alpha/analytics_admin.proto

package com.google.analytics.admin.v1alpha;

public interface ListMeasurementProtocolSecretsResponseOrBuilder
    extends
    // @@protoc_insertion_point(interface_extends:google.analytics.admin.v1alpha.ListMeasurementProtocolSecretsResponse)
    com.google.protobuf.MessageOrBuilder {

  /**
   *
   *
   *

   * A list of secrets for the parent stream specified in the request.
   *

   *
   *
   * repeated .google.analytics.admin.v1alpha.MeasurementProtocolSecret measurement_protocol_secrets = 1;
   *
   */
  java.util.List<com.google.analytics.admin.v1alpha.MeasurementProtocolSecret>
      getMeasurementProtocolSecretsList();
  /**
   *
   *
   *

   * A list of secrets for the parent stream specified in the request.
   *

   *
   *
   * repeated .google.analytics.admin.v1alpha.MeasurementProtocolSecret measurement_protocol_secrets = 1;
   *
   */
  com.google.analytics.admin.v1alpha.MeasurementProtocolSecret getMeasurementProtocolSecrets(
      int index);
  /**
   *
   *
   *

   * A list of secrets for the parent stream specified in the request.
   *

   *
   *
   * repeated .google.analytics.admin.v1alpha.MeasurementProtocolSecret measurement_protocol_secrets = 1;
   *
   */
  int getMeasurementProtocolSecretsCount();
  /**
   *
   *
   *

   * A list of secrets for the parent stream specified in the request.
   *

   *
   *
   * repeated .google.analytics.admin.v1alpha.MeasurementProtocolSecret measurement_protocol_secrets = 1;
   *
   */
  java.util.List<? extends com.google.analytics.admin.v1alpha.MeasurementProtocolSecretOrBuilder>
      getMeasurementProtocolSecretsOrBuilderList();
  /**
   *
   *
   *

   * A list of secrets for the parent stream specified in the request.
   *

   *
   *
   * repeated .google.analytics.admin.v1alpha.MeasurementProtocolSecret measurement_protocol_secrets = 1;
   *
   */
  com.google.analytics.admin.v1alpha.MeasurementProtocolSecretOrBuilder
      getMeasurementProtocolSecretsOrBuilder(int index);

  /**
   *
   *
   *

   * A token, which can be sent as `page_token` to retrieve the next page.
   * If this field is omitted, there are no subsequent pages.
   *

   *
   * string next_page_token = 2;
   *
   * @return The nextPageToken.
   */
  java.lang.String getNextPageToken();
  /**
   *
   *
   *

   * A token, which can be sent as `page_token` to retrieve the next page.
   * If this field is omitted, there are no subsequent pages.
   *

   *
   * string next_page_token = 2;
   *
   * @return The bytes for nextPageToken.
   */
  com.google.protobuf.ByteString getNextPageTokenBytes();
}


Maylor et al., 2008). As such, it can be argued that structural aspects relate to the physical composition and configuration of the project system and/or the elements in its environment that, in most cases, are necessary, but not sufficient attributes to induce complexity in projects. Nonetheless, it is widely acknowledged that large-scale complicated projects can still induce managerial challenges depending on the nature of its structure and the interdependencies between its elements; for example, challenges relating to dealing with intricacy and messiness, which could generally be dealt with using the existing project management body of knowledge.
As stated earlier, projects can be considered as "socio-technical systems" consisting of people, processes, and structures, which interact with other systems and actors in their environments. Therefore, in addition to the structural aspects that induce intricacy or messiness, technological change, uncertain environments, and the shifting stakeholder expectations may mean that: ( 1) project goals may not always be clear or set firmly at the conceptual development phase; ( 2) changes in client requirements may lead to ongoing changes in project scope and schedule; and ( 3) when technical methods of developing products are not known at the outset, the fundamental building blocks, such as work breakdown structures, could become ineffective.
additional resources need to be allocated; and so on.
2010; Geraldi, 2008; Kadanoff, 1986).
1972). Remington and Pollack (2007, p. 3) claimed that "most large and many small projects exhibit characteristics such as phase transition, adaptiveness and sensitivity to initial conditions." The effects of such properties and characteristics make projects function as complex systems described in mainstream complexity science literature.
An even higher-level of "dynamic" complexity may result from the combined effects of such properties as self-organization and learning (in addition to emergence) possessed by elements of a project system. This could be treated as the 'complex adaptive systems' described in complexity science literature. For example, Whitty and Maylor (2009, p. 305) asserted that truly complex projects "have multiple structural elements interacting and changing as they progress" and that "they are socially constructed entities." This could mean, for example, project teams or team members learning from their past experiences; in other words, how they responded to a certain situation and what the outcome was; and adapting their behaviors to differently respond to a future situation, so that the desired project goals are achieved. Such actions, however, may not always result in desirable outcomes, as they might be mediated or moderated by external influences. At an aggregate level, project systems might also display such adaptive behavior and evolution, through transforming into higher levels of maturity, for example, in terms of negotiations with stakeholders or mitigating risks.
This may also be interpreted in terms of organizational maturity levels discussed in project management literature.


After a long day of destroying Death Stars and battling storm troopers, you need to relax. Kick back with our comfy R2-D2 slippers! Modeled after the spunky little astromech droid, these slippers feature an embroidered radar eye, holographic projector, indicator light, and more--the perfect accessory for any Jedi in training.
Made with velvety soft plush, foam footbeds, non-slip grips on soles, and the official Star Wars logo.


Who does not love a pleasant and fresh smell coming from their home? We all fancy a clean home and are willing to do a lot to keep it super clean with no odor. However, we are also in love with pets and want to cuddle with them while in the house. Anybody who lives with a pet knows very well that he or she will deal with the pet's stains and smell every day. As such, you have to find a way to keep your house smelling fresh while still keeping your pet happy and active. Using professional deodorizers and sanitizers we will work diligently to remove those pet odors from your carpet.
Are you moving into a new house that had pets or do you have pets of your own that spend time on your carpet? Well, whichever situation you are in, we are the right experts for pet odor removal around you. Sometimes pets may leave stains that are hard to get out on your carpet alongside an odor that is pungent. You need worry no more because with our pet stain removers and extraordinary cleaning services, you will attain the home you desire.
Carpet Cleaning North Bay is here for you. We will help you deal with those pet stains and smells that make your home inhabitable. Your home will have the freshness that you desire within a matter of minutes because our experts are trained to deal with even the worst of situations. Our experts will help you deal with the problem regardless of whether it is in your home, office, commercial point, or car.
Our dedicated, honest, and reliable crew will provide the best services for you depending on your needs at a very low cost. In fact, we offer a 5 percent discount on initial order for our wide variety of pet odor removal services. This juicy offer makes our services very affordable while still maintaining the superior quality!
These carpet-cleaning services can either be routine or heavy cleaning depending on your needs and budget. To ensure your satisfaction, we use deep carpet cleaners as well as odor removers for efficiency. This is contrary to the services you will receive from the rest of the carpet cleaners in North Bay.
The residents of North Bay, Ontario in need of carpet and upholstery cleaning services will find our services satisfactory. They just need to give us a call today on 705-482-0370 and experience guaranteed high quality dirt and odor removal services. Better yet, they could visit our website www.carpetcleaningnorthbay.ca to learn more about us and schedule an appointment with our experts.
You need us to help your family live in a clean, healthy house. This is because dirt is associated with some diseases and health conditions that include an allergy to dust, spores, and pollen. Laying on dirty, smelly carpets or furniture is also risky to your health. Why don't you call us today to have your carpet, rugs, furniture, and other items cleaned by an excellent cleaning crew with high standard products!
Carpet Cleaning North Bay is your number one cleaning company that provides high quality and affordable services. We ensure that all our cleaning products like stain removers and the equipment are high quality with high levels of efficacy. This gives us the opportunity to keep our customers satisfied because your happiness is our satisfaction.
Why do you need to go for an ordinary pet odor removing company when we can provide you with excellent cleaning services beyond the shampoo cleaning stage? We will steam and go further since we know that every stain or smell on your carpets does not necessarily come from pets or simple spills.
We are not only local, but also mobile to ensure that we access every community with convenience. Do not think of throwing away a good carpet because of stains or odor. We will offer carpet and upholstery cleaning and remove odor from your carpet thus restoring and renewing your house. The more refreshed your residence is the more confidence and comfortable you get.
What are you waiting for! Call us today and experience our unbelievably extraordinary deals for our unique services. We are here for you as you try to create a clean, refreshed home for yourself and your pet.
Get my Free Estimate Now.


Angela Webster, Education Advisor at Netsafe, presented her research into pre-teens and privacy.
Ben Creet, Issues Manager at InternetNZ, discussed direct messaging apps and the privacy levels associated with popular apps.
The session was chaired by Jordan Carter, CE of InternetNZ.
The event was held as a part of Privacy Week 2017 (8-12 May).
The session was live-streamed using Periscope. The recording can be viewed here.