Junction tree algorithm
We have seen how the variable elimination (VE) algorithm can answer marginal queries of the form for both directed and undirected networks.
However, this algorithm still has an important shortcoming: if we want to ask the model for another query, e.g. , we need to restart the algorithm from scratch. This is very wasteful and computationally burdensome.
Fortunately, it turns out that this problem is also easily avoidable. When computing marginals, VE produces many intermediate factors as a side-product of the main computation; these factors turn out to be the same as the ones that we need to answer other marginal queries. By caching them after a first run of VE, we can easily answer new marginal queries at essentially no additional cost.
The end result of this chapter will be a new technique called the Junction Tree (JT) algorithm; this algorithm will first execute two runs of the VE algorithm to initialize a particular data structure holding a set of pre-computed factors. Once the structure is initialized, it will be used to answer marginal queries in time.
We will introduce two variants of this algorithm: belief propagation, and then the full junction tree method. The first one will apply to tree-structured graphs, while the other will be applicable to general networks.
Belief propagation
Variable elimination as message passing
First, consider what happens if we run the VE algorithm on a tree in order to compute a marginal . We can easily find an optimal ordering for this problem by rooting the tree at and iterating through the nodes in post-orderA postorder traversal of a rooted tree is one that starts from the leaves and goes up the tree such that a node is always visited after all of its children. The root is visited last. .
This ordering is optimal because the largest clique that formed during VE will be of size 2. At each step, we will eliminate ; this will involve computing the factor , where is the parent of in the tree. At a later step, will be eliminated, and will be passed up the tree to the parent of in order to be multiplied by the factor before being marginalized out. We can visualize this transfer of information using arrows on a tree.
Message passing order when using VE to compute on a small tree.
In a sense, when is marginalized out, it receives all the signal from variables underneath it from the tree. Because of the tree structure (variables affect each other only through their direct neighbors), this signal can be completely summarized in a factor . Thus, it makes sense to think of the as a message that sends to to summarize all it knows about its children variables.
At the end of the VE run, receives messages from all of its immediate children, marginalizes them out, and we obtain the final marginal.
Now suppose that after computing , we wanted to compute as well. We would again run VE elimination with as the root. We would again wait until receives all messages from its children. The key insight here is that the messages will receive from will be the same as when was the rootAnother reason why this is true is because there is only a single path connecting two nodes in the tree. . Thus, if we store the intermediary messages of the VE algorithm, we can quickly recompute other marginals as well.
A message-passing algorithm
A key question here is how exactly do we compute all the messages we need. Notice for example, that the messages to from the side of will need to be recomputed.
The answer is very simple: a node sends a message to a neighbor whenever it has received messages from all nodes besides . It’s a fun exercise to the reader to show that there will always be a node with a message to send, unless all the messages have been sent out. This will happen after precisely steps, since each edge can receive messages only twice: once from , and once more in the opposite direction.
Finally, this algorithm will be correct because our messages are defined as the intermediate factors in the VE algorithm.
Sum-product message passing
We are now ready to formally define the belief propagation algorithm. This algorithm will have two variants, the first of which is called sum-product message passing. This algorithm is defined as follows: while there is a node ready to transmit to , send the message
Again, observe that this message is precisely the factor that would transmit to during a round of variable elimination with the goal of computing .
Because of this observation, after we have computed all messages, we may answer any marginal query over in constant time using the equation
Sum-product message passing for factor trees
The sum-product message passing variant of belief propgation can also be applied to factor trees, with a slight modification. Recall that a factor graph is a bipartite graph with edges going between variables and factors, with an edge signifying a factor depends on a variable. We can perform VE on factor graphs through a modified version of the above algorithm.
On factor graphs, we have two types of messages: variable-to-factor messages and factor-to-variable messages .
Both messages require taking a product, but only the factor-to-variable messages require a sum.
So now the algorithm proceeds in the same way as above: as long as there is a factor or variable ready to transmit to a variable or factor, respectively, send the appropriate factor-to-variable or variable-to-factor message as defined above.
Max-product message passing
So far, we have said very little about the second type of inference we are interested in performing, which are MAP queries
The framework we have introduced for marginal queries now lets us easily perform MAP queries as well. The key observation to make, is that we can decompose the problem of MAP inference in exactly the same way as we decomposed the marginal inference problem by replacing sums with maxes.
For example, we may compute the partition function of a chain MRF as follows:
To compute the mode of , we simply replace sums with maxes, i.e.
The key property that makes this work is the distributivity of both the sum and the max operator over products. Since both problems are essentially equivalent (after swapping the corresponding operators), we may reuse all of the machinery developed for marginal inference and apply it directly to MAP inference. Note that this also applies to factor trees.
There is a small caveat in that we often want not just the mode of a distribution, but also its most probable assignment. This problem can be easily solved by keeping back-pointers during the optimization procedure. For instance, in the above example, we would keep a backpointer to the best assignment to given each assignment to , a pointer to the best assignment to given each assignment to and so on.
Junction tree algorithm
So far, our discussion assumed that the graph is a tree. What if that is not the case? Inference in that case will not be tractable; however, we may try to massage the graph to its most tree-like form, and then run message passing on this graph.
At a high-level the junction tree algorithm will try to achieve this by partitioning the graph into clusters of variables; internally, the variables within clusters could be highly coupled; however, interactions among clusters will have a tree structure, i.e. a cluster will be only directly influenced by its neighbors in the tree. This will lead to tractable global solutions if some local (cluster-level) problems can be solved exactly.
An illustrative example
Before we define the full algorithm, let us first start with an example, like we did for the variable elimination algorithm.
Suppose that we are performing marginal inference and that we are given an MRF of the form
Crucially, we will assume that the cliques have a form of path structure, meaning that we can find an ordering with the property that if and for some variable then for all on the path between and . We refer to this assumption as the running intersection property (RIP).
Suppose that we are interested in computing the marginal probability in the above example. Given our assumptions, we may again use a form of variable elimination to “push in” certain variables deeper into the product of cluster potentials:
We first sum over , which creates a factor . Then, gets eliminated, and so on. At each step, each cluster marginalizes out the variables that are not in the scope of its neighbor. This marginalization can also be interpreted as computing a message over the variables it shares with the neighbor.
The running intersection property is what enables us to push sums in all the way to the last factor. We may eliminate because we know that only the last cluster will carry this variable: since it is not present in the neighboring cluster, it cannot be anywhere else in the graph without violating the RIP.
Junction trees
The core idea of the junction tree algorithm is to turn a graph into a tree of clusters that are amenable to the variable elimination algorithm like the above MRF. Then we simply perform message-passing on this tree.
Suppose we have an undirected graphical model (if the model is directed, we consider its moralized graph). A junction tree over is a tree whose nodes are associated with subsets of the graph vertices (i.e. sets of variables); the junction tree must satisfy the following properties:
- Family preservation: For each factor , there is a cluster such that .
- Running intersection: For every pair of clusters , every cluster on the path between contains .
Here is an example of an MRF with graph and junction tree . MRF potentials are denoted using different colors; circles indicates nodes of the junction trees; rectangular nodes represent sepsets (short for “separation sets”), which are sets of variables shared by neighboring clusters.
A junction tree defined over a tree graph. Clusters correspond to edges.
Example of an invalid junction tree that does not satisfy the running intersection property.
Note that we may always find a trivial junction tree with one node containing all the variables in the original graph. However, such trees are useless because they will not result in efficient marginalization algorithms.
Optimal trees are one that make the clusters as small and modular as possible; unfortunately, it is again NP-hard to find the optimal tree. We will see below some practical ways in which we can find good junction trees.
A special case when we can find the optimal junction tree is when itself is a tree. In that case, we may define a cluster for each edge in the tree. It is not hard to check that the result satisfies the above definition.
The junction tree algorithm
Let us now define the junction tree algorithm, and then explain why it works. At a high-level, this algorithm implements a form of message passing on the junction tree, which will be equivalent to variable elimination for the same reasons that BP was equivalent to VE.
More precisely, let us define the potential of each cluster as the product of all the factors in that have been assigned to . By the family preservation property, this is well-defined, and we may assume that our distribution is in the form
Then, at each step of the algorithm, we choose a pair of adjacent clusters in and compute a message whose scope is the sepset between the two clusters:
We choose only if has received messages from all of its neighbors except . Just as in belief propagation, this procedure will terminate in exactly steps. After it terminates, we will define the belief of each cluster based on all the messages that it receives
These updates are often referred to as Shafer-Shenoy. After all the messages have been passed, beliefs will be proportional to the marginal probabilities over their scopes, i.e. . We may answer queries of the form for by marginalizing out the variable in its beliefReaders familiar with combinatorial optimization will recognize this as a special case of dynamic programming on a tree decomposition of a graph with bounded treewidth.
To get the actual (normalized) probability, we divide by the partition function which is computed by summing all the beliefs in a cluster, .
Note that this algorithm makes it obvious why we want small clusters: the running time will be exponential in the size of the largest cluster (if only because we may need to marginalize out variables from the cluster, which often must be done using brute force). This is why a junction tree of a single node containing all the variables is not useful: it amounts to performing full brute-force marginalization.
Variable elimination over a junction tree
Why does this method work? First, let us convince ourselves that running variable elimination with a certain ordering is equivalent to performing message passing on the junction tree; then, we will see that the junction tree algorithm is just a way of precomputing these messages and using them to answer queries.
Suppose we are performing variable elimination to compute for some variable , where . Let be a cluster containing ; we will perform VE with the ordering given by the structure of the tree rooted at . In the example below, say that we choose to eliminate the variable, and we set as the root cluster.
First, we pick a set of variables in a leaf of that does not appear in the sepset between and its parent (if there is no such variable, we may multiply and into a new factor with a scope not larger than that of the initial factors). In our example, we may pick the variable in the factor .
Then we marginalize out to obtain a factor . We multiply with to obtain a new factor . Doing so, we have effectively eliminated the factor and the unique variables it contained. In the running example, we may sum out and the resulting factor over may be folded into .
Note that the messages computed in this case are exactly the same as those of JT. In particular, when is ready to send its message, it will have been multiplied by from all neighbors except its parent, which is exactly how JT sends its message.
Repeating this procedure eventually produces a single factor , which is our final belief. Since VE implements the messages of the JT algorithm, will correspond to the JT belief. Assuming we have convinced ourselves in the previous section that VE works, we know that this belief will be valid.
Formally, we may prove correctness of the JT algorithm through an induction argument on the number of factors ; we will leave this as an exercise to the reader. The key property that makes this argument possible is the RIP; it assures us that it’s safe to eliminate a variable from a leaf cluster that is not found in that cluster’s sepset; by the RIP, it cannot occur anywhere except that one cluster.
The important thing to note is that if we now set to be the root of the tree (e.g. if we set to be the root), the message it will receive from (or from in our example) will not change. Hence, the caching approach we used for the belief propagation algorithm extends immediately to junction trees; the algorithm we formally defined above implements this caching.
Finding a good junction tree
The last topic that we need to address is the question of constructing good junction trees.
- By hand: Typically, our models will have a very regular structure, for which there will be an obvious solution. For example, very often our model is a grid, in which case clusters will be associated with pairs of adjacent rows (or columns) in the grid.
- Using variable elimination: One can show that running the VE elimination algorithm implicitly generates a junction tree over the variables. Thus it is possible to use the heuristics we previously discussed to define this ordering.
Loopy belief propagation
As we have seen, the junction tree algorithm has a running time that is potentially exponential in the size of the largest cluster (since we need to marginalize all the cluster’s variables). For many graphs, it will be difficult to find a good junction tree, applying the algorithm will not be possible. In other cases, we may not need the exact solution that the junction tree algorithm provides; we may be satisfied with a quick approximate solution instead.
Loopy belief propagation (LBP) is another technique for performing inference on complex (non-tree structure) graphs. Unlike the junction tree algorithm, which attempted to efficiently find the exact solution, LBP will form our first example of an approximate inference algorithm.
Definition for pairwise models
Suppose that we are given an MRF with pairwise potentialsArbitrary potentials can be handled using an algorithm called LBP on factor graphs. We will include this material at some point in the future . The main idea of LBP is to disregard loops in the graph and perform message passing anyway. In other words, given an ordering on the edges, at each time we iterate over a pair of adjacent variables in that order and simply perform the update
We keep performing these updates for a fixed number of steps or until convergence (the messages don’t change). Messages are typically initialized uniformly.
Properties
This heuristic approach often works surprisingly well in practice.
Marginals obtained via LBP compared to true marginals obtained from the JT algorithm on an intensive care monitoring task. Results are close to the diagonal, hence very similar.
In general, however, it may not converge and its analysis is still an area of active research. We know for example that it provably converges on trees and on graphs with at most one cycle. If the method does converge, its beliefs may not necessarily equal the true marginals, although very often in practice they will be close.
We will return to this algorithm later in the course and try to explain it as a special case of variational inference algorithms.
| Index | Previous | Next |


Personalized Career Results
If a user chose to personalize the career database with either the Sokanu Career Test or Twitter Analysis (using IBM's Watson), this screen would walk them through the assessment of their choosing and then filter the Career Database based on their results.
Contact an Advisor
This section will contain the contact information for the student's guidance counselor, when available. There may also be contact information for admissions officers at their prospecive schools or from sponsoring schools.


Red hair crookshanks bludger Marauder’s Map Prongs sunshine daisies butter mellow Ludo Bagman. Beaters gobbledegook N.E.W.T., Honeydukes eriseD inferi Wormtail. Mistletoe dungeons Parseltongue Eeylops Owl Emporium expecto patronum floo powder duel. Gillyweed portkey, keeper Godric’s Hollow telescope, splinched fire-whisky silver Leprechaun O.W.L. stroke the spine. Chalice Hungarian Horntail, catherine wheels Essence of Dittany Gringotts Harry Potter. Prophecies Yaxley green eyes Remembrall horcrux hand of the servant. Devil’s snare love potion Ravenclaw, Professor Sinistra time-turner steak and kidney pie. Cabbage Daily Prophet letters from no one Dervish and Banges leg.
 Full moon Whomping Willow three turns should do it lemon drops. Locomotor trunks owl treats that will be 50 points, Mr. Potter. Witch Weekly, he will rise again and he will come for us, headmaster Erumpent horn. Fenrir Grayback horseless carriages ‘zis is a chance many would die for!
Alohamora wand elf parchment, Wingardium Leviosa hippogriff, house dementors betrayal. Holly, Snape centaur portkey ghost Hermione spell bezoar Scabbers. Peruvian-Night-Powder werewolf, Dobby pear-tickle half-moon-glasses, Knight-Bus. Padfoot snargaluff seeker: Hagrid broomstick mischief managed. Snitch Fluffy rock-cake, 9 ¾ dress robes I must not tell lies. Mudbloods yew pumpkin juice phials Ravenclaw’s Diadem 10 galleons Thieves Downfall. Ministry-of-Magic mimubulus mimbletonia Pigwidgeon knut phoenix feather other minister Azkaban. Hedwig Daily Prophet treacle tart full-moon Ollivanders You-Know-Who cursed. Fawkes maze raw-steak Voldemort Goblin Wars snitch Forbidden forest grindylows wool socks.


My Watch List
Log Out
Trending
Add to Lists
My Watch List
Log Out
My Stream
menu
Trending
Add to Lists
My Watch List
My Account
arrow_drop_down
What's Trending


--- layout: post status: publish published: true title: 'Episode #300 from Spring Training - Episode 7.03' author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 11059 wordpress_url: http://ivyenvy.com/?p=11059 date: '2015-03-16 00:10:21 +0000' date_gmt: '2015-03-16 05:10:21 +0000' categories: - Podcast tags: [] comments: - id: 17545 author: Ivy Envy author_email: '' author_url: '' date: '2015-03-16 08:43:14 +0000' date_gmt: '2015-03-16 13:43:14 +0000' content: Also, when you hear me say "report" when talking about the 3rd thing we introduced, replace that word with "recap". - id: 17546 author: Bob Hall author_email: '' author_url: '' date: '2015-03-16 08:54:55 +0000' date_gmt: '2015-03-16 13:54:55 +0000' content: 'Am liking thing #2 and thing #3 in particular...' - id: 17547 author: Ivy Envy author_email: '' author_url: '' date: '2015-03-16 08:56:15 +0000' date_gmt: '2015-03-16 13:56:15 +0000' content: Good. Glad to hear that, Bob Hall. We were hoping folks would be interested in those things. - id: 17548 author: Jason Mollett author_email: '' author_url: '' date: '2015-03-16 10:29:19 +0000' date_gmt: '2015-03-16 15:29:19 +0000' content: I'll have to listen again. I was feeling my craft beer binge. ---
Welcome to the 300th episode of The Ivy Envy Podcast. After 26 non-stop hours in a Toyota Corolla, Corey and Andy have arrived in Arizona for the Cubs Spring Training.
This is the first time we have been to Sloan Park and we talk about our impressions of the facility and what we saw both on the back fields and in the Spring Training game vs. the Reds today.
In the off-seasons, we try to implement changes and new things with IvyEnvy.com and The Ivy Envy Podcast. We have three items to share with you on the this episode.
We will be at Spring Training through Thursday evening. Follow us on Twitter and Instagram for updates, photos and videos.


With focus on the basic concepts of financial management, business management, and corporate operations, students are cultivated to think logically to acquaint themselves in the concepts and principles of accounting, business, and management. The emphasis on business, legal, and organizational context of analyzing assets, interpreting profitability, understanding financial positions, and preparing audit accounts are for the progress and development of the economy and the promotion of sustainable green business.
The HUMSS strand offers study of human behavior and society and analysis of arts, culture, literature, and politics, involving anthropology, psychology, political science, linguistics, and communication. Students are trained in reading, speaking, and writing, as well as culture, politics, and arts in people-oriented learning environment.
Using interdisciplinary and applied concepts and skills in engineering, math, science, and technology, students in the STEM strand are fostered in a learning environment to produce original ideas, objects, and structures, according to specifications in problem-based and project-based activities. This is for those who strive to be in the fields of agriculture, engineering, healthcare, mathematics and science.


| DOSE: |
1 hit |
oral |
LSD |
(blotter / tab) |
I know that many of you have read a lot of crap and propaganda about LSD, and I want you to know right off that I am NO EXPERT. I am just trying to tell you what I have experienced.
Late last year, I think in september, I used LSD for the first, and as of now, the last time. I dropped one tab with a friend of mine (who had dropped before), around 3 PM, (my first mistake, it was to late in the day). We had smoked up first, so for a while I wasn't really sure if I was high or tripping... (I didn't know if it had kicked in yet). After a while though, like 45 minutes, it became apparent that I was. I started to get really anxious, and I started to feel very strange. I asked my friend how he was feeling, and he told me that it was kicking in for him to. I glanced over at a clock, it was around 4. For what seemed like three hours, we just sat there, laughing at things... the most normal things seemed to me like the strangest, and everything made me laugh. I looked over at the clock again... it had been like 2 minutes.
My friend and I just kinda sat around in my basement laughing at stuff for like 4 hours... and then he went home, around 8.
I assumed that once I was alone, it would be more fun, and that I would be able to really let loose. BIG MISTAKE. It was my first time tripping, as I noted above, and I didn't know what I was getting myself into. To make a long story short, my trip became the trip from hell, I was scared out of my mind. However, the trip itself is NOT the important part. The important part of what I have to say comes after the trip.
Now before I continue I should mention that I am OCD, because that I think is relivent to what I am about to tell you.
About two months after my trip... Yes, it took me that long to figure this out... I began to notice that things were different then before... only I had the hardest time remembering if they happened before the trip, (which I doubt now). I was still having visuals! (and I still to this day am having visuals) Lots of the effects NEVER wentaway. Now I am not talking flashbacks, I am talking 24/7 from after my trip to present day. These effects are not as strong as on my trip, but they are apparent.
I went to a doctor recently... a psychiatrist... (I cant spell for my life). She looked up in once of her books, and found some disorder... a VERY RARE occurance, of LSD users who apparently suffered similar side effects. She noted that people who already have disorders such as OCD or schizophrenia or other also, have a greatly increased risk... anyways thats what she told me.
 All I know is that I tripped, and my trip never stopped. Maybe OCD contributed... I dont know for sure. However I havn't been able to find much about what I just told you about anywhere on the web, so I thought I would try and post it on Erowid and see if anything positive comes of it.
I sincerely hope this helps somebody... in some way.
- Zbt.
[erowid note: It sounds like he's referring to
Hallucinogen Persisting Perceptual Disorder an uncommon, but not unique, side effect in some people. For more about HPPD, check out
HPPD Online.]
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


does emoncms accept http POST or does it only work with GET?
currently i am uploading data to emoncms with http GET like this:
https://hostname/api/post?apikey=TOKEN&json={var1:200.2,var2:200,var3:100}
i would prefer to do http POST like this:
https://hostname/api/post
then put the json data, including the apikey, into the actual http POST payload. i anticipate having some rather large chunks of json data (feeds from more than 50 circuits/sensors for each sample) and i do not want to run into URL length issues.
is this supported by emoncms?
where is the API definition for how to interact with the emoncms server?
Re: posting data to emoncms
Hello powermeister, although emoncms does not currently do this, it would be a relatively easy fix to make ti happen, if you go to Controllers/api_controller and switch the $_GET lines to $_POST. that should do it.
A beginning on the api description can be found here: http://openenergymonitor.org/emon/node/192
Re: posting data to emoncms
thanks for that.
in the api page, could you add a column that indicates when each api element (each row in the api tables) was implemented? that way we would have a reference for not only what is actually implemented, but also when each feature was implemented (so we'll have a better idea of when to upgrade) and a map of what the unimplemented features/calls will look like (so we can have discussions about them and possibly go off and implement them).
for example, instead of just these columns:
actions | external api | access | internal api
have these columns:
actions | access | external api | internal api | when implemented
the 'when implemented' column would have the release number (or even the git hashcode) when the row became available.
Re: posting data to emoncms
Thanks for all the suggestions, I will add these columns in
Re: posting data to emoncms
Hello
I have a problem , is that the Interfacing with the emoncms models and database via the emoncms API does not work .
the method client.println("emoncms/api/post?apikey=YOURAPIKEY&json={power:200.2}");
don't have any result .
what should I do ?
Re: posting data to emoncms
Hello maha
Are you using client.println() along with the reset of the Arduino Ethernet sketch?
Have you tried accessing the API from your internet browser?
Re: posting data to emoncms
Hello,
I would like to ask:
1) In order to send data to Emoncms I have to open the browser and use a command like e.g http://localhost/emoncms/input/post.json?node=1&csv=100,200,300???
Assuming I use Java to get values from my analyzers. The only way to send data is to call Browser from java with link "http://localhost/emoncms/input/post.json?node=1&csv=100,200,300" and then close the browser using java, or maybe I can import the data using an other method.
2)If I want to use The Led in dashboard (green for 1 and red for 0) for a variable, do I need to create a Feed for this variable? I don;t want to have a log but only show the real-time status (when i say real-time I mean the last value (0 or 1) that was sent to Emoncms).
3)In order to create a feed and log Day Energy I get from my analyzers Power Values and Total Energy Values.
The Total Energy Value is an incremental variable that never goes to zero.
Can I use only the Power Value with the Power to kWh/d process so that the EmonCMS can calculate the daily energy consumption/production?
I should use the Total Energy Value with the Wh increment to khw/d process or with kWh to kWh/d process in order to get daily energy consumption/production if Power Value alone is not enough?
Thank you
George
Re: posting data to emoncms
Your multiple copies of this post have been deleted. Please do not post again if your submission does not appear, you should see a message explaining that it is held for moderation.


This page reads the text on a meme and tries to get it right. Memes are a tricky read!
NB: please only use meme images that you have consent to use!


|
WinPcap
4.1.3
|
Modules | |
| NPF I/O control codes | |
| NPF structures and definitions | |
| NPF functions | |
| NPF Just-in-time compiler definitions | |
This section documents the internals of the Netgroup Packet Filter (NPF), the kernel portion of WinPcap. Normal users are probably interested in how to use WinPcap and not in its internal structure. Therefore the information present in this module is destined mainly to WinPcap developers and maintainers, or to the people interested in how the driver works. In particular, a good knowledge of OSes, networking and Win32 kernel programming and device drivers development is required to profitably read this section.
NPF is the WinPcap component that does the hard work, processing the packets that transit on the network and exporting capture, injection and analysis capabilities to user-level.
The following paragraphs will describe the interaction of NPF with the OS and its basic structure.
NDIS (Network Driver Interface Specification) is a standard that defines the communication between a network adapter (or, better, the driver that manages it) and the protocol drivers (that implement for example TCP/IP). Main NDIS purpose is to act as a wrapper that allows protocol drivers to send and receive packets onto a network (LAN or WAN) without caring either the particular adapter or the particular Win32 operating system.
NDIS supports three types of network drivers:
NPF is implemented as a protocol driver. This is not the best possible choice from the performance point of view, but allows reasonable independence from the MAC layer and as well as complete access to the raw traffic.
Notice that the various Win32 operating systems have different versions of NDIS: NPF is NDIS 5 compliant under Windows 2000 and its derivations (like Windows XP), NDIS 3 compliant on the other Win32 platforms.
Next figure shows the position of NPF inside the NDIS stack:
Figure 1: NPF inside NDIS.
The interaction with the OS is normally asynchronous. This means that the driver provides a set of callback functions that are invoked by the system when some operation is required to NPF. NPF exports callback functions for all the I/O operations of the applications: open, close, read, write, ioctl, etc.
The interaction with NDIS is asynchronous as well: events like the arrival of a new packet are notified to NPF through a callback function (Packet_tap() in this case). Furthermore, the interaction with NDIS and the NIC driver takes always place by means of non blocking functions: when NPF invokes a NDIS function, the call returns immediately; when the processing ends, NDIS invokes a specific NPF callback to inform that the function has finished. The driver exports a callback for any low-level operation, like sending packets, setting or requesting parameters on the NIC, etc.
Next figure shows the structure of WinPcap, with particular reference to the NPF driver.
Figure 2: NPF device driver.
NPF is able to perform a number of different operations: capture, monitoring, dump to disk, packet injection. The following paragraphs will describe shortly each of these operations.
The most important operation of NPF is packet capture. During a capture, the driver sniffs the packets using a network interface and delivers them intact to the user-level applications.
The capture process relies on two main components:
A packet filter that decides if an incoming packet has to be accepted and copied to the listening application. Most applications using NPF reject far more packets than those accepted, therefore a versatile and efficient packet filter is critical for good over-all performance. A packet filter is a function with boolean output that is applied to a packet. If the value of the function is true the capture driver copies the packet to the application; if it is false the packet is discarded. NPF packet filter is a bit more complex, because it determines not only if the packet should be kept, but also the amount of bytes to keep. The filtering system adopted by NPF derives from the BSD Packet Filter (BPF), a virtual processor able to execute filtering programs expressed in a pseudo-assembler and created at user level. The application takes a user-defined filter (e.g. “pick up all UDP packets”) and, using wpcap.dll, compiles them into a BPF program (e.g. “if the packet is IP and the protocol type field is equal to 17, then return true”). Then, the application uses the BIOCSETF IOCTL to inject the filter in the kernel. At this point, the program is executed for every incoming packet, and only the conformant packets are accepted. Unlike traditional solutions, NPF does not interpret the filters, but it executes them. For performance reasons, before using the filter NPF feeds it to a JIT compiler that translates it into a native 80x86 function. When a packet is captured, NPF calls this native function instead of invoking the filter interpreter, and this makes the process very fast. The concept behind this optimization is very similar to the one of Java jitters.
A circular buffer to store the packets and avoid loss. A packet is stored in the buffer with a header that maintains information like the timestamp and the size of the packet. Moreover, an alignment padding is inserted between the packets in order to speed-up the access to their data by the applications. Groups of packets can be copied with a single operation from the NPF buffer to the applications. This improves performances because it minimizes the number of reads. If the buffer is full when a new packet arrives, the packet is discarded and hence it's lost. Both kernel and user buffer can be changed at runtime for maximum versatility: packet.dll and wpcap.dll provide functions for this purpose.
The size of the user buffer is very important because it determines the maximum amount of data that can be copied from kernel space to user space within a single system call. On the other hand, it can be noticed that also the minimum amount of data that can be copied in a single call is extremely important. In presence of a large value for this variable, the kernel waits for the arrival of several packets before copying the data to the user. This guarantees a low number of system calls, i.e. low processor usage, which is a good setting for applications like sniffers. On the other side, a small value means that the kernel will copy the packets as soon as the application is ready to receive them. This is excellent for real time applications (like, for example, ARP redirectors or bridges) that need the better responsiveness from the kernel. From this point of view, NPF has a configurable behavior, that allows users to choose between best efficiency or best responsiveness (or any intermediate situation).
The wpcap library includes a couple of system calls that can be used both to set the timeout after which a read expires and the minimum amount of data that can be transferred to the application. By default, the read timeout is 1 second, and the minimum amount of data copied between the kernel and the application is 16K.
NPF allows to write raw packets to the network. To send data, a user-level application performs a WriteFile() system call on the NPF device file. The data is sent to the network as is, without encapsulating it in any protocol, therefore the application will have to build the various headers for each packet. The application usually does not need to generate the FCS because it is calculated by the network adapter hardware and it is attached automatically at the end of a packet before sending it to the network.
In normal situations, the sending rate of the packets to the network is not very high because of the need of a system call for each packet. For this reason, the possibility to send a single packet more than once with a single write system call has been added. The user-level application can set, with an IOCTL call (code pBIOCSWRITEREP), the number of times a single packet will be repeated: for example, if this value is set to 1000, every raw packet written by the application on the driver's device file will be sent 1000 times. This feature can be used to generate high speed traffic for testing purposes: the overload of context switches is no longer present, so performance is remarkably better.
WinPcap offers a kernel-level programmable monitoring module, able to calculate simple statistics on the network traffic. The idea behind this module is shown in Figure 2: the statistics can be gathered without the need to copy the packets to the application, that simply receives and displays the results obtained from the monitoring engine. This allows to avoid great part of the capture overhead in terms of memory and CPU clocks.
The monitoring engine is made of a classifier followed by a counter. The packets are classified using the filtering engine of NPF, that provides a configurable way to select a subset of the traffic. The data that pass the filter go to the counter, that keeps some variables like the number of packets and the amount of bytes accepted by the filter and updates them with the data of the incoming packets. These variables are passed to the user-level application at regular intervals whose period can be configured by the user. No buffers are allocated at kernel and user level.
The dump to disk capability can be used to save the network data to disk directly from kernel mode.
Figure 3: packet capture versus kernel-level dump.
In traditional systems, the path covered by the packets that are saved to disk is the one followed by the black arrows in Figure 3: every packet is copied several times, and normally 4 buffers are allocated: the one of the capture driver, the one in the application that keeps the captured data, the one of the stdio functions (or similar) that are used by the application to write on file, and finally the one of the file system.
When the kernel-level traffic logging feature of NPF is enabled, the capture driver addresses the file system directly, hence the path covered by the packets is the one of the red dotted arrow: only two buffers and a single copy are necessary, the number of system call is drastically reduced, therefore the performance is considerably better.
Current implementation dumps the to disk in the widely used libpcap format. It gives also the possibility to filter the traffic before the dump process in order to select the packet that will go to the disk.
The structure of NPF and its filtering engine derive directly from the one of the BSD Packet Filter (BPF), so if you are interested the subject you can read the following papers:
- S. McCanne and V. Jacobson, The BSD Packet Filter: A New Architecture for User-level Packet Capture. Proceedings of the 1993 Winter USENIX Technical Conference (San Diego, CA, Jan. 1993), USENIX.
- A. Begel, S. McCanne, S.L.Graham, BPF+: Exploiting Global Data-flow Optimization in a Generalized Packet Filter Architecture, Proceedings of ACM SIGCOMM '99, pages 123-134, Conference on Applications, technologies, architectures, and protocols for computer communications, August 30 - September 3, 1999, Cambridge, USA
The code documented in this manual is the one of the Windows NTx version of NPF. The Windows 9x code is very similar, but it is less efficient and lacks advanced features like kernel-mode dump.
documentation. Copyright (c) 2002-2005 Politecnico di Torino. Copyright (c) 2005-2010 CACE Technologies. Copyright (c) 2010-2013 Riverbed Technology. All rights reserved.


Although the capital of Italy is known for its delicious restaurants, beautiful architecture, stellar beaches and a brilliant shopping scene, the best events in Rome are exciting happenings worth travelling to Europe all on their own for. Bringing tourists and locals out together into town piazzas, gardens and cultural venues, these annual festivities function as deep-dives into a slice of culture that, usually, only Romans get to experience.
If you’re in town at the end of September, Taste of Roma should be on your to-do list. This enormous food festival is a great way to eat your way through the city and sample the cuisines of Rome’s best chefs and emerging food personalities.
The Ides of March, Rome marks the anniversary of Julius Caesar’s untimely death with a period reenactment. Caesar was one of Rome's most important dictators and he was murdered by his own senators.This unique event sees dozens of actors and actresses dress up in Roman togas and engage in animated discussions before dealing Julius Caesar the final blow.
When in Rome, you can’t miss the chance to taste all the wines, and a great place to do just that is at VinòForum, a wine festival held in the north of Rome each June.feature over 2,500 wines from 500 producers, along with pop-up restaurants serving gourmet foods prepared by Michelin-starred chefs. You can also sign up for master classes and guided wine tastings at the VinoForum Academy.
The best Italian pizzaioli (pizza makers) gather in Rome annually to celebrate one of the country’s most beloved foods. Expect to devour all sorts of variations on the classic, from the fluffy Neapolitan pie to the thin Roman-crust one, fried pizza and pizza by the slice.
From the far end of this long hilltop road, the dome appears large and imposing, but as you walk towards the dome you’ll begin to see the optical illusion. The nearer you get, the smaller the dome appears to the point where it looks tiny.
Know MoreThe Vatican museum is an art and sculpture museum in Vatican City The Vatican museum is too big and has lavishly decorated halls and galleries. Explore the museum with a picture gallery and sculptures.
Know MoreAn enormous, life-size panorama, known as THE WALL, to recreate life on both sides of the notorious Berlin Wall, which divided the city for almost 30 years, on an imaginary autumn day.Seen from atop a 13-foot and learn about life in the shadow of the Wall at a photo exhibition too.
Know More


Koan Loc
Home
Portfolio
Contact
Portfolio
Code Refractor
Deployed Link
See Code in GitHub
Password Generator
Deployed Link
See Code in GitHub
COVID-19 Tracker
Deployed Link
See Code in GitHub
Notes
Deployed Link
See Code in GitHub
Management System
Video
See Code in GitHub
Restaurant App
Deployed Link
See Code in GitHub
Nutrition Tracker
Deployed Link
See Code in GitHub


Methods
(static) addParticle(particle)
Adds new particle into array of objects to check for intersection with the ray.
Available as raycaster.stereo.addParticle( particle ).
raycaster is Raycaster instance.
Parameters:
| Name |
Type |
Description |
particle |
THREE.Mesh
|
The Mech or derived class instance for check for intersection with the ray. |
- Source:
- See:
-
(static) addParticles(newParticles)
New array of objects to check for intersection with the ray.
Available as raycaster.stereo.addParticles( particles ).
raycaster is Raycaster instance.
Parameters:
| Name |
Type |
Description |
newParticles |
array
|
New array of objects to check for intersection with the ray. |
- Source:
- See:
-
(static) getPosition(intersection)
get position of intersected object
Available as raycaster.stereo.getPosition( intersection ).
raycaster is Raycaster instance.
Parameters:
| Name |
Type |
Description |
intersection |
object
|
first item of array of intersections. |
- Source:
- See:
-
(static) isAddedToParticles(particle)
Available as raycaster.stereo.isAddedToParticles( particle ).
raycaster is Raycaster instance.
Parameters:
| Name |
Type |
Description |
particle |
THREE.Mesh
|
The Mech or derived class instance for check is added to particles. |
- Source:
Returns:
true if particle is added to particles.
(static) onDocumentMouseMove(event)
mousemove event.
User is moving of mouse over canvas.
Parameters:
| Name |
Type |
Description |
event |
object
|
|
- Source:
(static) removeParticle(particle)
Remove particle from array of objects to check for intersection with the ray.
Available as raycaster.stereo.removeParticle( particle ).
raycaster is Raycaster instance.
Parameters:
| Name |
Type |
Description |
particle |
THREE.Mesh
|
The Mech or derived class instance for removing from array of objects for check for intersection with the ray. |
- Source:
- See:
-
(static) removeParticles()
remove array of objects to check for intersection with the ray.
Available as raycaster.stereo.removeParticles().
raycaster is Raycaster instance.
- Source:
- See:
-


This past weekend I went to an event hosted by a local App Development Agency. It was a great time and, while there, I ran into a college student who brought his college’s computer club. He asked me if I had any thoughts on how to teach his fellow students programming. It was a great question to ask an experienced engineer, and I figured I would share some of the advice I gave him here, but specifically about Android.
Books
One of the most obvious ways to learn anything: pick up a book. Initially, this is how I started to learn Android development. I grabbed a book, started to read through it and work the examples.
The great thing about learning through books is you can learn at your own pace. You can take your time reading or you can speed read. You also get to keep the book forever as a reference, that’s what I did with my book. There are also a great variety of books written, so you can find one that suits your learning style.
The downside about books is how fast they fall behind the pace of technology. I have a book sitting on my bookcase about Javascript and JQuery, but the current push in the web development world seems to be Redux (you hardly hear about JQuery jobs lately). This time lag is obviously due to how long it takes to write and publish a book. So, if you are going to choose a book, make sure it was published recently (not a year ago).
Bootcamps
If you are looking the learn Android quickly, then perhaps a Bootcamp is for you. Bootcamps are courses put together by experts in the field and usually last about the week. They aim to teach you the bare minimum to get you started as an Android Developer and you are expected to have some minimum knowledge of Java before starting.
The difficulty with Bootcamps is that they usually don’t go in depth with the inner workings of Android. They will point you in the right direction, but won’t tell you about things like the Dex limit or Multidexing (things very important to an Android Developer).
When looking for a Bootcamp, check to ensure they teach you through projects and that there is a large project you add to throughout your time there. This helps you showcase what you can do to future employers and aids in learning Android.
Project
Do you have an app you wish someone would make? Well, make it yourself! The best way to learn anything is to just do it. Yes, you will make a lot of mistakes and it may be frustrating at times, but there’s plenty of resources out there to help you. People have written numerous blogposts about the different techniques you can use to implement your app.
True, your app may not be the best, but it is definitely going teach you a lot. You can also use the project to showcase your abilities, helping you land a job with other Android Developers.
Go Learn
Hopefully, these tips help to give you an idea on where you can start learning Android. So, go learn! Being willing to make mistakes and learn from them. Feel free to reach out for help.


As a Computer Science graduate at University of Waterloo, My strongest assets are in programming, having deep knowledge in various languages and algorithms which I earned from my University career.
Driven from strong basics, I can adapt to different development environments (such as new languages and frameworks, etc.) much faster than the others.
I'm always curious of how things are done in practical way, that's why I'm passionate towards learning new technologies and discovering new techniques.


Moderator: Joe M.
Karl G. wrote:You're not supposed to list that huge numbers of items. As more gold is found I think the cost will be reasonable.
Karl G. wrote:Xenimus: not enough items, world isn't big enough, boring to level and the new spell system isn't as much fun as the old one.
EJ. Thayer wrote:If you don't like it then Quit.
Richard. UK wrote:The bazaar is working brilliantly. and perfectly fine as it is.
It is a great invention for preventing the rich getting richer. Or at least making the economy of gold less inflated.
It will help prevent (completely stop?) people hoarding gold and becoming godly with money.
Return to Suggestions & Requests
Users browsing this forum: No registered users and 1 guest


MAIN MENU
Home
About rabbits
Guestbook
Calculator
Set homepage
MY BOOKMARKS
CPAN
Perl Doc
Perl Monks


'That first half was beautiful!' Wolves fans delighted with Bournemouth win - WATCH
Wolves fans spoke to Nathan Judah following the 2-1 win over Bournemouth at the Vitality Stadium.
by Nathan JudahJoao Moutinho and Raul Jimenez fired Wolves to a 2-1 victory over 10-man Bournemouth.
Portuguese ace Moutinho's sublime set-piece opened the scoring in the 21st minute with Jimenez netting his 14th of the term just after the half-hour mark.
Bournemouth lost Simon Francis to a second yellow card in the 37th minute but Eddie Howe's men came out fighting in the second 45.
After Diogo Jota saw his effort controversially ruled out by the offside flag Steve Cook popped up at the other end to set up a tense finish.


advances in machine-learning (abstract)
{find more citations}
| ZotWeb | paper-conference | |
| Src Url | [[Morris]], [[Secretan]] (2009) | |
The emergence of computers as a core component of creative processes, coupled with recent advances in machine-learning, signal-processing, and algorithmic techniques for manipulating creative media, offers tremendous potential for building end-user creativity-support tools. However, the scientific community making advances in relevant algorithmic techniques is not, in many cases, the same community that is currently making advances in the design, evaluation, and user-experience aspects of creativity support. The primary objective of this workshop is thus to bring together participants from diverse backgrounds in the HCI, design, art, machine-learning, and algorithms communities to facilitate the advancement of novel creativity support tools.
The emergence of computers as a core component of creative processe
advances in machine-learnin
Keywords
Outils de support à la créativité, exploration de données (data-mining)
is intended to bring together participants from multiple communities who share an interest in creativity suppor
Identify potential collaborations among the communities represented her
Facilitate discussion of the tools and methodologies
Facilitate discussion of the implementation and evaluation challenge
This workshop aims to bring together diverse communities to foster the advancement of creativity support tools, and we expect that it will be a unique opportunity to exchange tools and experiences from communities outside your own. If you are active in this space, or have a strong personal interest in this space and work on relevant tools or methodologies, consider submitting to Computational Creativity Support 200
Shneiderman, B., “Creativity Support Tools: Accelerating Discovery and Innovation,” Communications of the ACM, Vol. 50, No. 12, 2007
Howe, D.C. RiTa: Creativity Support for Generative Literature. Proc Generative Art Intl Cof, 2008.
Keefe, D.F., Acevedo, D., Miles, J., Drury, F., Swartz, S.M., Laidlaw, D.H. Scientific Sketching for Collaborative VR Visualization design. IEEE Trans Visualization Comp Graph, 14(4):835-847, 200
Sheppard, R.M, Kamali, M., Rivas, R., Tamai, M., Yang, Z., Wu, W., Nahrstedt, K. Advancing Interactive Collaborative Mediums through Tele- immersive Dance (TED): a Symbiotic Creativity and Design Environment for Art and Computer Science. ACM Intl Conf on Multimedia (MM'08), 2008.
Citer: (Morris & Secretan, 2009)
FTag: Morris-Secretan-2009
APA7: Morris, D., & Secretan, J. (2009). Computational creativity support: Using algorithms and machine learning to help people be more creative. CHI ’09 Extended Abstracts on Human Factors in Computing Systems, 4733–4736. https://doi.org/10.1145/1520340.1520728


I have a bunch of EmonTHs with the DS18B20 in the DHT22 socket and I want to add multiple external DS18B20s as well.
I can find sketches for a DS18B20 in the DHT22 socket and I can find sketches for multiple external DS18B20s, but not a sketch that combines both.
Does something like that exist? I am not a programmer, so my feeble attempts to mash the two together never made it past the compiling stage.
Thanks
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
Why do you think you need to use DS18B20s in both places? How many do you need, and how are they wired (star or in-line)?
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
Hi Robert -
I need three temp sensors on one particular emonTH. I have an onboard DS18B20 sensor already installed in the DHT22 socket (ordered from OEM this way) and I have two external DS18B20s connected via the terminal block (both of them connected directly to the terminal block) in a star configuration.
I guess I could just add a third external DS18B20 to the emonTH but I was hoping to use the temp sensor already onboard.
I have one sketch that recognizes the DS18B20 in the DHT22 socket as well as a sketch that allows me to see multiple external DS18B20s, but I cannot get a sketch to work that does both, and that was what I was looking for on this particular emonTH.
I was just wondering if someone already had a sketch to do that....
Thanks (again) :-)
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
I don't know of a sketch, but it should not be difficult to combine the two. But by far the easiest solution - as you can't successfully do the sketch - would be to add the third sensor to the terminal block.
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
Could you not just bridge the on-board temp data pin and the external temp data pin on the emonTH and use the multiple external sketch with the on-board code looking to an unused pin so it thinks there is no on-board sensor and 3 external despite the physical location?
Adding a short piece of wire and changing a pin number might be an easy enough route.
Paul
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
Well, it is not as pretty as some code out there, but I finally managed to get a sketch working with two external DS1820B sensor and another DS1820B in the DHT22 socket.
Since I am not a programmer, this took a long time for me to figure out, but it was fin and in the end, it works great.
I have the serial set to 38400 because for some reason below that I get partial garbage out of the IDE. Just a line or two, but still annoying. I also have it set for (°F) as I am in the US.
Maybe this will help someone else out there!
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
You probably needed 38400 Baud because the serial output didn't complete in time - it's interrupt-driven and if another interrupt comes along, the timing goes awry. Adding a small delay after the offending "Serial.print" usually does the trick.
Re: EmonTH w/Multiple external DS18B20 AND DS18B20 in DHT22 socket Sketch
Thanks Robert -
Adjusting the delay will give me some tinkering to do!


In this example the content to be flown is composed of both TextNodes and IMGs.
The Forbidden City was the Chinese imperial palace from the Ming Dynasty to the end of the Qing Dynasty. It is located in the middle of Beijing, China, and now houses the Palace Museum. For almost 500 years, it served as the home of emperors and their households, as well as the ceremonial and political center of Chinese government.
Built in 1406 to 1420, the complex consists of 980 buildings and covers 720,000 m2 (7,800,000 sq ft).[1] The palace complex exemplifies traditional Chinese palatial architecture,[2] and has influenced cultural and architectural developments in East Asia and elsewhere. The Forbidden City was declared a World Heritage Site in 1987,[2] and is listed by UNESCO as the largest collection of preserved ancient wooden structures in the world.
Since 1925, the Forbidden City has been under the charge of the Palace Museum, whose extensive collection of artwork and artifacts were built upon the imperial collections of the Ming and Qing dynasties.
Notes: This text is from Wikipedia. Pictures taken by me.


All voices that are playing the same sound belong to the same virtual {_instrument}. From the keyboard, you can play on two instruments, called the Main and Link, and each {_USB_device_port} MIDI input channel can also play on a separate instrument.
The stereo outputs of all voices belonging to a particular instrument are summed together, and then processed further. The instrument architecture looks like this:
{instrument-architecture.png width=595}
The BASS, MIDDLE and TREBLE modules are stereo tone controls on the combined sound from all voices playing on that instrument. The sliders on the panel adjust the levels of these tone controls for the Main instrument, but these are actually parameters in the program, not master tone controls on the final output. While SET SPLIT is flashing, the sliders instead adjust the bass, middle, and treble frequencies, and the TUNE slider adjusts the middle resonance.
The DISTORTION module is also controlled by an {_extended_parameter} in the {_program}.
Reverberation is controlled by a level control and a room select, so the output always goes to the dry output, and also goes to one of the rooms. These choices are normally performance controls generated by global parameters, but there are extended program parameters that can override this, in case a particular sound always needs particular reverb settings.
Finally, the instrument also includes some control signal generation:


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 3-4
Dietary
This is a simple, spicy Indian snack made with rice and potatoes. Perfect as a side dish with curry too.
Boil the potatoes until cooked. Drain and set aside to cool, then peel and cut into 1cm/½in cubes.
Put the rice in a sieve and wash gently but thoroughly under cold running water. Empty it into a bowl, cover generously with water and leave to soak for two minutes. Drain and leave in the sieve set over a bowl.
Put the oil in a large, non-stick frying pan and set it over a medium-high heat. When hot, add the asafoetida and the urad dal. As soon as the dal starts to pick up a little colour, add the mustard seeds, cumin seeds and chilli (whatever type you are using). As soon as the mustard seeds start to pop, a matter of seconds, add the curry leaves (take care as they will splutter), then the onion and potatoes. Lower to a medium heat and fry, stirring now and again, for 3-4 minutes or until the onion and potatoes are slightly browned.
Sprinkle a pinch of salt over the top and stir.
Add the poha rice, gently breaking up any lumps, and sprinkle ½ teaspoon of salt and one teaspoon sugar over the top. Cook on a low heat for 3-4 minutes, tossing frequently by lifting all the ingredients from the bottom of the pan with a flat spatula and folding them over, until the poha is heated through. Cover and set aside until you are ready to eat.
To make the salad, mix all the ingredients in a large bowl.
To serve, garnish the poha potatoes with fresh coriander and serve with lime or lemon wedges. Serve the salad alongside.


Project List Sony 3DCG R&D : OnSpecta : 2017-present : 2012-2017 : 2007-2012 : 2004-2007 : 2000-2004
Sony
- 3D Volumetric Performance Capture link
Onspecta
- BERT Optimization
- Pytorch Vs TensorFlow link
- Benchmarking link
- Architecture link
- Weight Pruning link
- Resnet50 optimization link
- Quantization link
Washington State University
- NSVF link
- Gan based controllable pose and dress link
- Segment videos based on events and classify them link
- Jpg image classifer
- Compression experiments link
- Combinatorial experiments link
- ML tutorials - list of experiments to understand various types of networks and different ml paradigms link
- Computational genomics link
- AGI - brain project
- Video compression - GAN based, progressive GAN, VQ-VAE-2
- In Media Product Placement - DensePose, 3d-kenburns, detectron2, InGAN, SinGAN, StyleGAN-2, vid2vid, few-shot-vid2vid
- multi agent RL
- Pose Comparison
- Deep Neural Network Inference Optimization:
- Transformer Quantization - Classification and Seq
- Pytorch Quantization - Tensorflow Quantization
- Pruning
- ARM platform
- ResNet Quantization
- Virtual Studio - ADGAN, CPISADGAN, Image HArmonization, LIP_SSL, Human Segmentation, Single-Human-Parsing-LIP,
- Nerfies, PoseTransfer
- vdo mocap -
- HumanModels - PifuHD, CAPE, OpenPose, HairNet,
- Multi view rendering
- Cloth hair pose gen - ADGAN, PArsing-R-CNN, pi-GAN-pytorch, tex2shape
- colmap, DeepSDF, nerf,
- nerf_universe - kilonerf, NSVF, pixel-nerf, nerf in the wild,
[code] - Pose based nerf - densepose-siren, image_interp, pose2d_cnn, pose2d_gen, pose2d_siren, syn_data_train
- NeRF++, NSVF, NSVF_update
- neural_sparse_voxel_field - 1D signal encoding, analysis, fourier_feature_experiment, image_encoding, mesh_generation
- Vdo_mocap - dancebabydance
- detectron2, Detr, EasyMocap, FRankMocap, human_body_prior,
- nerf++, neuralbody, pifuhd, pixel2style2pixel
- pose_to_mocap, video2bvh, VIBE, SPIN, SMPL, SMPLX, SMPLify-X, SMPLicit
- theta_beta_iteration
- MeshTransformer
- video_pose_estimation
- videoavatars, VideoPose3D, White-Box-Cartoonization - Cartoon Generation, Dress extractor, Vtuber
Polycom
- Video Conferencing plugin} for chrome 64 bit using PPAPI
- RTP, RDP and HTML5 based Content Collaboration} between MCU, Lync and Browser endpoints
- Automation Platform for bringing up Infrastructure for Video as a service on VMWare
- Platform Director: Life cycle management of virtual instances on VMWare using viJava
Ittiam Systems
- Mpeg2 (MP@HL) HD(1080i@30fps) Encoder/Transcoder for Broadcast on Netra (IVAHD Accel)
- MPEG4 Simple Profile (SP) HD(720p@30fps) Encoder for Smart Phones on OMAP34xx (Arm+DSP+IVA)
- Mpeg4 SP D1 (480p@30fps) Encoder for Portable Media Player and Recorder on OMAP3430.
- Mpeg4 Advanced Simple Profile HD Decoder on OMAP3430
- Mpeg4, H.263 and Mpeg2 Encoders for catalogue products on C64x+ DSP
- Handling 3:2 pulldown by reducing frame rate and generation of Timestamp information
- Migrating the mpeg4 ME optimizations to MPEG2 non-accelerated workspace
- Adding MV cost for Motion Estimation [MPEG4 non-accelerated]
- H263 Encoder and its extensions D1 on C64x+ DSP
- Added XDM 1.0 API support for Mpeg4 non accelerated version
- Optimization of MPEG4 non accelerated encoder
Tata Elxsi
- ‘N’ mb level optimization of core loop Difference+DCT+Q+IQ+IDCT.
- Study of SD H.264 Scalable Video Codec on SCP
- Real Time HD (High Definition) MPEG2 Video Encoder on Multiple SCP (S5) Processors
- Real Time HD H.264 Video Encoder On Multiple SCP (S5) Processors
- H.264 Encoder modules development
- Real Time Preview of HD bit streams on PC
- Study on video transcoding of HD MPEG2 bit streams to SD (Standard Definition) bit streams
Anna University
- Visualization of White Matter Fiber Tract from DT-MR (Diffusion Tensor Magnetic Resonance) Image.
- Micro-Controller based Personal Data Assistant using MC89C51
Kaggle projects


To reach the next level: Team Leader , you need 500 more points in balance.
New levels are reached by building your binary balance and earning money in Crowd1. A new level will give you access to a higher long-term residual income. When you reach level 10 (Director ) you will be invited to a luxury VIP Cruise!
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| Team Leader | 500 | Pool 1 | |
| Team Leader | 1.000 | Pool 2 | |
| Team Leader | 2.500 | Pool 3 |
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| Coordinator | 5.000 | Pool 4 | |
| Coordinator | 10.000 | Pool 5 | |
| Coordinator | 25.000 | Pool 6 |
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| Manager | 50.000 | Pool 7 | |
| Manager | 100.000 | Pool 8 | |
| Manager | 250.000 | Pool 9 |
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| Director | 500.000 (Luxury VIP Cruise Autumn 2020) | Pool 10 | |
| Director | 1.000.000 | Pool 11 | |
| Director | 2.500.000 | Pool 12 |
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| President | 5.000.000 | Pool 13 | |
| President | 10.000.000 | Pool 14 | |
| President | 25.000.000 | Pool 15 |
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| Senior President | 50.000.000 | Pool 16 | |
| Senior President | 75.000.000 | Pool 17 | |
| Senior President | 100.000.000 | Pool 18 |
| Title | Level | Binary Points in balance | Income Pool |
|---|---|---|---|
| Ambassador | 200.000.000 | Pool 19 | |
| Ambassador | 400.000.000 | Pool 20 | |
| Ambassador | 800.000.000 | Pool 21 |


{% load static %}
Master's Student
Ke is a student in the Master of Science in Biomedical Science program. His work focuses on building more predictive models of microorganisms.


| DOSE: |
1 tablet |
oral |
MDMA |
(pill / tablet) |
when i first started using 'E' it was awesome. everyone used to tell me and my friends to stop doing it because it was terrible and going to mess us up in the long run..but..YA RIGHT..we didnt listen. it was the best feeling when you pop one and then 30 minutes later your calf muscles are tensing and tingling, your head is getting light and your jaw is tightening. you could just walk in the club and have the best time..even if you were the only ones there. it didnt matter, you were on E.
i started doing it about a yr and a half ago. i started by a friend telling me to try. and oh boy did i try. i loved it SOO much i was out doing it every weekend. but i didnt care it was so fun even if it did cause damage. it was at the point where i FELT like i always wanted it and 1/2 the time i didnt but my body just remembered its feeling and wanted more... i was popping 3 a week sometimes.. that may not be as bad compared to many but it was to me.
i tried to stop it about 5 months after i started..but i couldnt stop. i just slowed down with my usage. that may be a step foward from what it was before but i wish there was more for me to do then just WANT to stop.
here i am a yr. and a 1/2 later on my 30-35th pill and i am just starting to feel some real side effects. who knows if that is the reason i get ALL of them, but i believe it is. i got a real bad anxiety attack on Xmas Eve that scared the SHIT out of me. i have constant headaches and HORRIBLE mood swings. my boyfriend says i'm 'like doctor jeckle & Mr. Hyde'. one minute i will love him the next i am being a bitch or crying my eyes out about nothing. another thing thats not REAL bad is...i do get depressed alot more easily then before. the last thing that really bothers me is the fact that i have shooting pains through my heart & chest. it feels kind of like a heartburn but i know that its not that. i want to get it checked out but what am i gunna say? 'its from all the MDMA use i did...?' umm nooo..
the grossiest part of this is.. i have 1 pill upstairs for me to pop this coming sunday...am i crazy or what??? i just wish in a way i never even got myself into it...but on the other hand..its the best thing i have experienced in my life..
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Budget
Category Name
Submit
Expense Name
Expense Date
Expense Amount
Category Name
Submit
Income Name
Income Date
Income Amount
Category Name
Submit


// Server side
tether.listen('add article', (Article article) {
articles.add(article);
// Realtime broadcasting events
tetherManager.broadcast('article was added', article);
});
// Client side
var article = new Article('Bridge is amazing!');
tether.send('add article', article);


Before Change
NOTE: The upper and lower bounds are inclusive for `Integer`
dimensions.
dim_types = [check_dimension(d) for d in dimensions]
is_cat = all([isinstance(d, Categorical) for d in dim_types])
if is_cat:
transformed_dims = [check_dimension(d, transform="identity")
for d in dimensions]
else:
After Change
// recreate the space and explicitly set transform to "identity"
// this is a special case for GP based regressors
for dimension in space:
transformed_dimensions.append(Categorical(dimension.categories,
dimension.prior,
transform="identity"))
else:
for dimension in space.dimensions:


|
||||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES |
CitrusleafClient
object and initializes
logging framework.
CitrusleafClient.CitrusleafClient()
and
addHost()
.
null
bin name and value.
setLogging()
, so the caller can channel Citrusleaf client
logs as desired.scan...()
calls, so the caller can be notified with scan results.
|
||||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES |


Getting Started The difference between building a plugin and a project component lies in flexibility.
The first thing we are going to is take a step back and think about the requirements.
Our modal plugin should: Launch different
modals based upon option sets Allow users to define custom transitions Be responsive Have max/min width points Anchor to the top of the page if too tall Be centered otherwise Accept a HTML string for content OR a domNode Have no
dependencies See that last line?
Thats right folks, we're doing this in plain old Javascript.
The Javascript Architecture Alright, lets get our hands dirty.
Our first order of business is going to be deciding on our
plugin architecture and picking a design pattern.
Let's create an IIFE to create a closure we can work within.
Closures can be leveraged to create a private scope, where you have control over what data you make available.


I hope your hunger for understanding will be enough to motivate you to read a couple of difficult chapters. If you do, you will learn something few J programmers know--what really happens when J executes a sentence. In this chapter we will analyze sentences from the top down, to get an idea for the order of execution. In the next chapter we will follow the interpreter as it alternately parses and executes sentences from the bottom up.
Since the understanding of parsing and execution that you have developed during your work so far is probably a bit inaccurate, we will work through examples of increasing complexity.
9!:3 (5) NB. Do this once to select simplified display
&.
&.
With only one word, there are no operands and nothing to execute, so the result of the sentence is the word itself: the conjunction &. .
-:&.^.
-:&.^.
The result of executing -:&.^., i. e. executing &. with -: and ^. as operands, is an anonymous verb. This anonymous verb will execute according to the definition of &., given its operands -: and ^. (i. e. -:&.^. y will be ^ -: ^. y ).
Note that the conjunction &. is executed without reference to the operand of the anonymous verb (indeed, in this case there is no such operand and the anonymous verb is the result of the sentence). We could assign the anonymous verb to a name, in which case it would no longer be anonymous (e. g. sqrt =: -:&.^.); without such an assignment we will refer to it here by the nickname av . The value of av is the verb described by -:&.^. .
-:&.^. 16
4
We know that this is executed as ^ -: ^. 16; let's see how that happens. Conjunctions are executed before verbs, so first -:&.^. will be executed to produce the anonymous verb we called av . Then av is executed with the operand 16 . av operates according to the definition of &. : it produces the same result as ^ -: ^. 16 (but it may use a different algorithm than executing ^ -: ^. 16 directly).
It appears that &. was executed twice: once to create av and then again during the execution of av . No, it was executed only once, to create av . av operates according to the definition of &., but it is av that is executing, not &. . The confusion arises because of the way the interpreter displays av . There is no better way to show a verb that performs the function -:&.^. than to show the way the verb was created, i. e. with the characters '-:&.^.', but you should think of this as an exhibition of the pedigree of av, and an assurance of its good behavior, rather than a list of functions to be executed. In fact, part of the reason for J's good performance comes from its recognizing functions that can be combined efficiently and providing customized routines to handle anonymous verbs that call for those combinations.
Confusion between a conjunction and the anonymous verb it produces is most likely when the conjunction is one you wrote using conjunction define or 2 :n . In most cases the text of the conjunction actually describes a derived verb, and it is natural for you to say 'the conjunction C is executed with operands u, v, and y' rather than the more accurate 'the anonymous verb created by the application of C to u and v is executed, with u and v available during the interpretation of the text of C and with y as the operand'. Such confusion is almost always harmless, but let's go through a few examples so you can see the layers of execution:
2 : 'u'
2 : 'u'
We execute 2 : 'u' and the result is an anonymous conjunction that we'll call ac1 . The display of ac1 shows where it came from. When ac1 is executed, its result will be its left operand.
+: (2 : 'u') -:
+:
Here 2 : 'u' is executed first to produce ac1; then ac1 is executed with left operand of +: and right operand of -: . The result is an anonymous verb that we'll call av1; its value is the verb +: which was the left operand to ac1 .
+: (2 : 'u') -: 5
10
Remember, (2 : 'u') is a conjunction (the conjunction we have called ac1), and conjunctions are executed before verbs, so this is executed as (+: (2 : 'u') -:) 5, which becomes av1 5 . We execute av1 with the operand 5 . Monad +: doubles its operand, and the result is 10 .
We know that a conjunction can produce a conjunction result. That's how explicit conjunctions are formed: executing the conjunction : with left operand 2, as in 2 :n, produces a conjunction. There is nothing special about 2 :n : any conjunction is allowed to produce a conjunction result:
2 : '&'
2 : (,'&')
We execute 2 : '&' and the result is an anonymous conjunction that we'll call ac2 . The display of ac2 shows where it came from. (the , in the display of ac2 is harmless, a reminder that internally the anonymous entity resulting from m :n stores n as a list of characters.)
+: (2 : '&') -:
&
We execute ac2 with left operand of +: and right operand of -: . The result is an anonymous conjunction that we'll call ac3 . ac3 is a conjunction because its value & (the last sentence executed by ac2) is a conjunction. Yes, & by itself can be a result: modifiers can return any primary part of speech (but try to return a conjunction from a verb and you will get an error).
Note that this is not the same as u&v : that would also be a valid return value from a conjunction, but u and v would be substituted and & would be executed to make the returned value an anonymous verb with the description u&v .
Make sure
you see why the +:
and -:
disappeared. First, the conjunction :
was executed with operands 2 and '&'; that
produced a conjunction ac2 which was then executed with operands +:
and -:;
but the defining text of ac2 does not look at its operands; it
simply produces the value & .
So, the operands to ac2 disappear without a trace, and the
result of the whole phrase is a conjunction with the value & .
2 (+: (2 : '&') -:) *
2&*
Continuing the example, we execute ac3 (which was just the conjunction &) with left operand 2 and right operand * . The result is the anonymous verb av2 which will execute as 2&* .
2 (+: (2 : '&') -:) * 5
10
Finally, we execute av2 with the operand 5, and get the result 10 .
Definitions That Refer To x or y
Explicit modifiers that refer to the operands of their derived verb (as x or y) come in for special treatment. A simple example is the conjunction defined by
2 : 'u v y'
2 : 'u v y'
We execute 2 : 'u v y' and the result is an anonymous conjunction that we'll call ac4 . You can't tell it from the display, but ac4 is a special kind of conjunction. Because it refers to y, the text of ac4 can be executed only as a verb (only then are x and y meaningful). The stored ac4 makes note of this fact.
+: (2 : 'u v y') - 5
_10
When ac4 itself is executed (as +: (2 : 'u v y') - here--since ac4 is a conjunction it is executed before its result is applied to the noun operand 5), the text of ac4 is not interpreted, as it was in our previous examples. Instead, the new anonymous verb av3 is created. av3 contains the defining text of ac4, along with the operands that were given to ac4 (+: and - here). When the verb av3 is executed as in the line above, the text of ac4 is finally interpreted, with the operands of ac4 (+: and - here) available as u and v, and the noun operands of av3 (5 here) available as y (and x if the invocation is dyadic); the result is the result of +: - 5 .


It looks like another tab for this {{ entity }} editor page has unsaved changes. Please navigate to that tab and save or discard those changes first before continuing with this tab. Otherwise, any changes you make on this tab will be lost.
NOTE: This pop-up will automatically close once the unsaved changes from the other tab have been saved or discarded.


RT @confreaks: New Video! #cascadiaruby2013 - Ruby as Art; Ruby as Science; Ruby as Craft by @davystevenson http://www.confreaks.com/videos/2789-cascadiaruby2013-ruby-as-art-ruby-as-science-ruby-as-craft
11/28/2013, 9:22:51 PM
Favs: 0
Retweets: 0
link


Q6. You have written a function myfun and want to measure how long it takes to run. Which code segment will return in t the time in seconds it takes myfun to run?
Q9. Which function could you use for multiple linear regression?
[ ] polyval
[x] regress
[ ] solve
[ ] polyfit
Q10. For which of these arrays do mean, median, and mode return the same value?
[x] [0 1 1 1 2]
[ ] [1 3 5 5 6]
[ ] [0 1 1 1 1]
[ ] [0 0 5 5 5]
Q11. You are in the middle of a long MATLAB session where you have performed many analyses and made many plots. You run the following commands, yet a figure window doesn’t pop up on the top of your screen with your plot. What might be the issue?
Q15. You have plotted values of cosine from -10 to 10 and want to change the x-axis tick marks to every pi, from -3pi to 3pi. Which statement will do that?
Q28. Which statement returns the roots for the polynomial x^2 + 2x - 4?
[ ] poly([1 2 -4])
[ ] solve(x^2 + 2x - 4 == 0)
[ ] polyfit(x^2 + 2x - 4 == 0)
[x] roots([1 2 -4])
Q29. Which choice is the proper syntax to append a new elements a to the end of 1x 2 dimensional cell array C?
[ ] C = {C a};
[ ] C = cellcat(C a)
[ ] C = cat(2, {a}, C)
[x] C{end+1}=a
Q30. You have loaded a dataset of people’s heights into a 100 x 1 array called height. Which statement will return a 100 x 1 array, sim_height, with values from a normal distribution with the same mean and variance as your height data?
Q37. You have a matrix data in which each column is mono audio recording from a room in your house. You’ve noticed that each column has a very different mean and when you plot them all on the same graph, the spread across the y axis make it impossible to see anything. You want to subtract the mean from each column. Which code block will accomplish this?


{{tally.correctTotal}} correct answers {{tally.incorrectTotal}} incorrect answers Total score: {{tally.correctTotal}}/{{tally.total}} ({{tally.correctTotal*100/tally.total}}%)


Here will be displayed the talks you want to attend. To attend a talk, visit a talk and push the "Attend this talk" button.


Jeff's Bikes is a database of bikes including tons of info on each one. This site allows for updating and editing of bikes that you have added. You can also comment on bikes, search for bikes, and generally geek out on bikes! :)


Introduction
This document describes the data model of the output of the
SelfControlledCaseSeries (SCCS) package, generated by the
exportToCsv()
function. This vignette assumes you are
already familiar with the SelfControlledCaseSeries
package,
and have read all other vignettes.
Exposures, covariates of interest, and controls
As described in the ‘Single studies using the
SelfControlledCaseSeries package’ vignette, eras are
cohorts or drug eras extracted from the database.
Covariates can either be splines, for example
representing age or season, or era covariates, derived from eras. When
defining covariates using the createEraCovariateSettings()
function we can either use verbatim era IDs (e.g. cohort IDs), or we can
reference a variable (typically called ‘exposureId’). When defining
exposures using the exposure()
function,
we can define different era IDs to be used for this variable, thereby
using the same analysis settings for different exposures and outcomes.
For each exposure we can set the trueEffectSize
if known.
Any exposure with known true effect size is considered a
control
, and will be used for empirical calibration. Some
of our covariates can be marked as covariates of
interest by setting exposureOfInterest = TRUE
when
calling createEraCovariateSettings()
. This is especially
relevant for the results model, since these covariates will be reported
in the sccs_result
table.
Exposures-outcome-sets, analysis IDs and models
Using the createExposuresOutcome()
function we can
define an outcome with one or more exposures, since an SCCS model can
have multiple exposures (e.g. we could have separte exposures for the
first and second dose of a vaccine). With the
createSccsAnalysis()
function we can create a set of
settings for analysis describing which data to extract from the
database, how to transform that data including which covariates to
construct, and how to fit the SCCS model. Each analysis setting has a
unique analysis ID. Each combination of an exposures-outcome-set and an
analysis setting will correspond to one SCCS model. A model can have
multiple covariates, and each covariates can be based on multiple
eras.
Fields with minimum values
Some fields contain patient counts or fractions that can easily be
converted to patient counts. To prevent identifiability, these fields
are subject to a minimum value. When the value falls below this minimum,
it is replaced with the negative value of the minimum. For example, if
the minimum subject count is 5, and the actual count is 2, the value
stored in the data model will be -5, which could be represented as
‘<5’ to the user. Note that the value 0 is permissible, as it
identifies no persons. These fields are identified below as having Min.
count = ‘Yes’.
Tables
In this section you will find the list of tables and their
fields.
Table sccs_age_spanning
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| age_month |
int |
Yes |
No |
Age in months since birth. |
| cover_before_after_subjects |
int |
No |
Yes |
Number of subjects whose observation period covers this
month as well as the one before and after. |
Table sccs_analysis
| analysis_id |
int |
Yes |
No |
A unique identifier for an analysis. |
| description |
varchar |
No |
No |
A description for an analysis, e.g. ‘Correcting for age
and season’. |
| definition |
varchar |
No |
No |
A JSON object specifying the analysis. |
Table sccs_attrition
| sequence_number |
int |
Yes |
No |
The place in the sequence of steps defining the final
analysis cohort. 1 indicates the original exposed population without any
inclusion criteria. |
| description |
varchar |
No |
No |
A description of the last restriction, e.g. “Removing
persons with the outcome prior”. |
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| covariate_id |
int |
Yes |
No |
A foreign key referencing the sccs_covariate table. The
identifier for the covariate of interest. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| outcome_subjects |
int |
No |
Yes |
The number of subjects with at least one outcome. |
| outcome_events |
int |
No |
Yes |
The number of outcome events. |
| outcome_observation_periods |
int |
No |
Yes |
The number of observation periods containing at least
one outcome. |
| observed_days |
bigint |
No |
Yes |
The number of days subjects were observed. |
Table sccs_calendar_time_spanning
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| calendar_year |
int |
Yes |
No |
Calendar year (e.g. 2022) |
| calendar_month |
int |
Yes |
No |
Calendar month (e.g. 1 is January). |
| cover_before_after_subjects |
int |
No |
Yes |
Number of subjects whose observation period covers this
month as well as the one before and after. |
Table sccs_censor_model
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| parameter_id |
int |
Yes |
No |
The parameter number in the censor model (starting at
1). |
| parameter_value |
float |
No |
No |
The fitted parameter value. |
| model_type |
varchar |
No |
No |
The type of censor model. Can be ‘Weibull-Age’.
‘Weibull-Interval’, ‘Gamma-Age’, or ‘Gamma-Interval’. |
Table sccs_covariate
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| covariate_id |
int |
Yes |
No |
A unique identifier for a covariate. |
| covariate_name |
varchar |
No |
No |
A description for the covariate. |
| era_id |
int |
No |
No |
A foreign key referencing the sccs_era table. |
| covariate_analysis_id |
int |
No |
No |
A foreign key referencing the sccs_covariate_analysis
table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
Table sccs_covariate_analysis
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| covariate_analysis_id |
int |
Yes |
No |
A unique identifier for a covariate analysis. |
| covariate_analysis_name |
varchar |
No |
No |
A name for a covariate analysis,
e.g. ‘Pre-exposure’. |
| variable_of_interest |
int |
No |
No |
Is the variable of interest (1 = yes, 0 = no). |
Table sccs_covariate_result
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| covariate_id |
int |
Yes |
No |
The identifier for the covariate. |
| rr |
float |
No |
No |
The estimated relative risk (i.e. the incidence rate
ratio). |
| ci_95_lb |
float |
No |
No |
The lower bound of the 95% confidence interval of the
relative risk. |
| ci_95_ub |
float |
No |
No |
The upper bound of the 95% confidence interval of the
relative risk. |
Table sccs_diagnostics_summary
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| covariate_id |
int |
Yes |
No |
The identifier for the covariate of interest. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| mdrr |
float |
No |
No |
The minimum detectable relative risk. |
| ease |
float |
No |
No |
The expected absolute systematic error. |
| time_trend_p |
float |
No |
No |
The family-wise p for whether the monthly outcome rate
is equal to the mean. |
| pre_exposure_p |
float |
No |
No |
One-sided p-value for whether the rate before expore is
higher than after, against the null of no difference. |
| mdrr_diagnostic |
varchar(20) |
No |
No |
Pass / warning / fail / not evaluated classification of
the MDRR diagnostic. |
| ease_diagnostic |
varchar(20) |
No |
No |
Pass / warning / fail / not evaluated classification of
the EASE diagnostic. |
| time_trend_diagnostic |
varchar(20) |
No |
No |
Pass / warning / fail / not evaluated classification of
the time trend (unstalbe months) diagnostic. |
| pre_exposure_diagnostic |
varchar(20) |
No |
No |
Pass / warning / fail / not evaluated classification of
the time trend (unstalbe months) diagnostic. |
| unblind |
int |
No |
No |
Is unblinding the result recommended? (1 = yes, 0 =
no) |
Table sccs_era
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| analysis_id |
int |
Yes |
No |
A unique identifier for an analysis. |
| era_type |
varchar |
Yes |
No |
The type of era (e.g. ‘rx’ for drugs). |
| era_id |
int |
Yes |
No |
A unique identifier, corresponding to the ID in the
source table (e.g. cohort_definition_id in a cohort table, or the
drug_concept_id in the drug_era table). |
| era_name |
varchar |
No |
No |
A name for the era. Is NULL for eras derived from
cohorts. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
Table sccs_event_dep_observation
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| months_to_end |
int |
Yes |
No |
Number of months until observation end. |
| censored |
int |
Yes |
No |
Whether the observation is censored (meaning, not equal
to the end of database time). (1 = censored, 0 = not censored). |
| outcomes |
int |
No |
Yes |
Number of outcomes observed during the month. |
Table sccs_exposure
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| era_id |
int |
Yes |
No |
A foreign key referencing the sccs_era table. |
| true_effect_size |
float |
No |
No |
If known, the true effect size. For negatitive controls
this equals 1. |
Table sccs_exposures_outcome_set
| exposures_outcome_set_id |
int |
Yes |
No |
A unique identifier for a set of exposures and an
outcome. |
| outcome_id |
int |
No |
No |
A cohort ID. |
Table sccs_likelihood_profile
| log_rr |
float |
Yes |
No |
The log of the relative risk where the likelihood is
sampled. |
| log_likelihood |
float |
No |
No |
The normalized log likelihood. |
| covariate_id |
int |
Yes |
No |
The identifier for the covariate of interest. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
Table sccs_result
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| covariate_id |
int |
Yes |
No |
A foreign key referencing the sccs_covariate table. The
identifier for the covariate of interest. |
| rr |
float |
No |
No |
The estimated relative risk (i.e. the incidence rate
ratio). |
| ci_95_lb |
float |
No |
No |
The lower bound of the 95% confidence interval of the
relative risk. |
| ci_95_ub |
float |
No |
No |
The upper bound of the 95% confidence interval of the
relative risk. |
| p |
float |
No |
No |
The two-sided p-value considering the null hypothesis
of no effect. |
| outcome_subjects |
int |
No |
Yes |
The number of subjects with at least one outcome. |
| outcome_events |
int |
No |
Yes |
The number of outcome events. |
| outcome_observation_periods |
int |
No |
Yes |
The number of observation periods containing at least
one outcome. |
| covariate_subjects |
int |
No |
Yes |
The number of subjects having the covariate. |
| covariate_days |
int |
No |
Yes |
The total covariate time in days. |
| covariate_eras |
int |
No |
Yes |
The number of continuous eras of the covariate. |
| covariate_outcomes |
int |
No |
Yes |
The number of outcomes observed during the covariate
time. |
| observed_days |
bigint |
No |
Yes |
The number of days subjects were observed. |
| log_rr |
float |
No |
No |
The log of the relative risk. |
| se_log_rr |
float |
No |
No |
The standard error of the log of the relative
risk. |
| llr |
float |
No |
No |
The log of the likelihood ratio (of the MLE vs the null
hypothesis of no effect). |
| calibrated_rr |
float |
No |
No |
The calibrated relative risk. |
| calibrated_ci_95_lb |
float |
No |
No |
The lower bound of the calibrated 95% confidence
interval of the relative risk. |
| calibrated_ci_95_ub |
float |
No |
No |
The upper bound of the calibrated 95% confidence
interval of the relative risk. |
| calibrated_p |
float |
No |
No |
The calibrated two-sided p-value. |
| calibrated_log_rr |
float |
No |
No |
The log of the calibrated relative risk. |
| calibrated_se_log_rr |
float |
No |
No |
The standard error of the log of the calibrated
relative risk. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
Table sccs_spline
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| spline_type |
varchar |
Yes |
No |
Either ‘age’, ‘season’, or ‘calendar time’. |
| knot_month |
float |
Yes |
No |
Location of the knot. For age, the month since birth.
For season, the month of the year. For calendar time, the month since
1-1-1970. |
| rr |
float |
No |
No |
The estimated relative risk (i.e. the incidence rate
ratio). |
Table sccs_time_to_event
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| era_id |
int |
Yes |
No |
A foreign key referencing the sccs_era table. The
identifier for the era of interest. |
| week |
int |
Yes |
No |
The number of the week relative to exposure. Week 0
starts on the day of exposure initiation. |
| observed_subjects |
int |
No |
Yes |
The numer of people observed during the week. |
| outcomes |
int |
No |
Yes |
The number of outcomes observed durig the week. |
Table sccs_time_trend
| analysis_id |
int |
Yes |
No |
A foreign key referencing the sccs_analysis table. |
| exposures_outcome_set_id |
int |
Yes |
No |
A foreign key referencing the
sccs_exposures_outcome_set table. |
| database_id |
varchar |
Yes |
No |
Foreign key referencing the database. |
| calendar_year |
int |
Yes |
No |
The calendar year (e.g. 2022). |
| calendar_month |
int |
Yes |
No |
The calendar month (e.g. 1 for January). |
| observed_subjects |
int |
No |
Yes |
Number of people observed during the month. |
| outcome_rate |
float |
No |
Yes |
Number of outcomes divided by the number of
subjects. |
| adjusted_rate |
float |
No |
Yes |
The outcome rate, adjusted for age, season, or calendar
time, as specified in the analysis. |
| stable |
int |
No |
No |
Does the adjusted rate not deviate significantly from
the mean? (1 = stable, 0 = unstable) |
| p |
float |
No |
No |
The two-sided p-value against the null hypothesis that
the rate is equal to the mean. |


Maureen Thuo
Projects
Services
About
Blog
Contact
Drop me a line
Email*
Name*
Tel.
Preferred means:
Tel.
Email
Product*
Photoshop
Proofreading
Data Entry
Message*
Subscribe to news and offers
Send Message
©2021.All Rights Reserved.™
Maureen Thuo