The primary objective of this project is to develop a predictive model for the detection of behavioral health challenges in high school students. By statistically analyzing academic performance records, this work seeks to identify early indicators of behavioral health challenges, thereby empowering school teachers and administrators to promptly identify and support students requiring access to additional school resources. Our model uses declining and fluctuating academic performance data as a marker for the onset of such challenges as depression, anxiety, and bipolar disorders. At the heart of our approach lies the development of a machine learning model composed of two essential components: a deep encoder and a classifier. The deep encoder performs feature extraction from time series data consisting of grades received by students in various course subjects. The encoder identifies and highlights inherent patterns within these sequences that hold key information necessary for the early detection of behavioral health challenges. The output embeddings from the encoder are then fed into the classifier to label the students into one of three groups - stable, monitor, or critical. This approach has achieved a remarkable 93% weighted F1 score on our test set.

With increasing frequency, teenagers and young adults are being diagnosed with such mental and behavioral health issues as depression, anxiety, mood disorders and addiction. In many cases, these conditions are not detected in a timely fashion-and sometimes not detected at all-thereby preventing access to needed treatment options by the patients affected. These conditions are often concomitant with sharply declining or widely fluctuating academic performance in school. Our long-term goal is to promote an early detection of mental and behavioral health issues in high school students through a statistical analysis of their academic performance. Here we discuss unsupervised learning methods seeking to classify students into three clusters of stable, monitor and critical students. A key goal of our work is to produce clusters whose size is consistent with statistics for adolescent mental health posted periodically by the US Centers for Disease Control and Prevention (CDC) and the National Alliance on Mental Illness (NAMI). Our analyses are based on a data set of academic performance data involving over 500 students in mid-sized high schools in the state of Illinois.

Over the past decade Online Social Networks (OSNs) have been helping hundreds of millions of people develop reliable computer-mediated relations. However, many user profiles in OSNs contain misleading, inconsistent or false information. Existing studies have shown that lying in OSNs is quite widespread, often for protecting a user's privacy. In order for OSNs to continue expanding their role as a communication medium in our society, it is crucial for information posted on OSNs to be trusted. Here we define a set of analysis methods for detecting deceptive information about user genders in Twitter. In addition, we report empirical results with our stratified data set consisting of 174,600 Twitter profiles with a 50-50 breakdown between male and female users. Our automated approach compares gender indicators obtained from different profile characteristics including first name, user name, and layout colors. We establish the overall accuracy of each indicator and the strength of all possible values for each indicator through extensive experimentations with our data set. We define male trending users and female trending users based on two factors, namely the overall accuracy of each characteristic and the relative strength of the value of each characteristic for a given user. We apply a Bayesian classifier to the weighted average of characteristics for each user. We flag for possible deception profiles that we classify as male or female in contrast with a self-declared gender that we obtain independently of Twitter profiles. Finally, we use manual inspections on a subset of profiles that we identify as potentially deceptive in order to verify the correctness of our predictions.

Online Social Networks (OSNs) generate a huge volume of user-originated texts. Gender classification can serve multiple purposes. For example, commercial organizations can use gender classification for advertising. Law enforcement may use gender classification as part of legal investigations. Others may use gender information for social reasons. Here we explore language independent gender classification. Our approach predicts gender using five color-based features extracted from Twitter profiles (e.g., the background color in a user's profile page). Most other methods for gender prediction are typically language dependent. Those methods use high-dimensional spaces consisting of unique words extracted from such text fields as postings, user names, and profile descriptions. Our approach is independent of the user's language, efficient, and scalable, while attaining a good level of accuracy. We prove the validity of our approach by examining different classifiers over a large dataset of Twitter profiles.

Online Social Networks (OSNs) provide reliable communication among users from different countries. The volume of texts generated by OSNs is huge and highly informative. Gender classification can serve commercial organizations for advertising, law enforcement for legal investigation, and others for social reasons. Here we explore profile characteristics for gender classification on Twitter. Unlike existing approaches to gender classification that depend heavily on posted text such as tweets, here we study the relative strengths of different characteristics extracted from Twitter profiles (e.g., first name and background color in a user's profile page). Our goal is to evaluate profile characteristics with respect to their predictive accuracy and computational complexity. In addition, we provide a novel technique to reduce the number of features of text-based profile characteristics from the order of millions to a few thousands and, in some cases, to only 40 features. We prove the validity of our approach by examining different classifiers over a large dataset of Twitter profiles.

Many organizations deploy applications that use databases by sending Structured Query Language (SQL) statements to them and obtaining data that result from executions of these statements. Since applications often share the same databases concurrently, database deadlocks routinely occur in these databases. Testing applications to determine how they cause database deadlocks is important as part of ensuring correctness, reliability, and performance of these applications. Unfortunately, it is very difficult to reproduce database deadlocks, since it involves different factors such as the precise interleavings in executing SQL statements. We created a novel approach for Systematic TEsting in Presence of DAtabase Deadlocks (STEPDAD) that enables testers to instantiate database deadlocks in applications with a high level of automation and frequency. We implemented STEPDAD and experimented with three applications. On average, STEPDAD detected a number of database deadlocks exceeding the deadlocks obtained with the baseline approach by more than an order of magnitude. In some cases, STEPDAD reproduced a database deadlock after running an application only twice, while no database deadlocks could be obtained after ten runs using the baseline approach.

Many organizations deploy applications that use databases by sending Structured Query Language (SQL) statements to them and obtaining data that result from the execution of these statements. Since applications often share the same databases concurrently, database deadlocks routinely occur in these databases resulting in major performance degradation in these applications. Database engines do not prevent database deadlocks for the same reason that the schedulers of operating system kernels do not preempt processes in a way to avoid race conditions and deadlocks - it is not feasible to find an optimal context switching schedule quickly for multiple processes (and SQL statements), and the overhead of doing it is prohibitive.

In this demonstration, we will present a database deadlocks prevention system that visualizes our algorithm for detecting hold-and-wait cycles that specify how resources (e.g., database tables) are locked and waited on to be locked during executions of SQL statements and utilizes those cycles information to prevent database deadlocks automatically.

Traditional analysis and design approaches focus on "fit for purpose." Experience with contextual environment concerns demonstrates that "fit to context" is a consideration that is equally significant for the appropriateness of the chosen architecture. We propose a multilevel, context-aware approach to software architecture that (1) treats contextual environment concerns as first class entities and (2) groups concerns and techniques of different abstraction, scope and grain into separate explicit levels. We categorize contextual environment concerns into enterprise and system. The proposed method groups software architecture in macro-architecture and micro-architecture levels. In a significant departure from most current software architecture practices, we view and treat macro-architecture as a decision analysis discipline while applying the engineering modeling and design practices used in traditional software architecture methods to the micro-architecture level. In this paper we introduce the software architecture approach and method, discuss our current research, and identify the topics that must be addressed and further defined to complete the method.

We define a method for the automatic generation of supervisory controllers that force a plant to perform a given operation by a given deadline. The operation must be executed by a prespecified delay λ with respect to the previous execution of the operation. Although our supervisor generation occurs offline with respect to plant execution, the resulting controllers automatically take into account variable task durations in an effort to increase the flexibility of operation schedules in the controlled plant. We model both the controlled plant and control supervisors as time Petri nets. In this setting, our control supervisors must force a target transitiontdto fire within λ time units since the previous firing oftd. Our supervisor generation is based on the concept of a transition latency. The latency of a Petri net transitiontis the time interval during whichtmust be disabled in order for target transitiontdto fire by its deadline. If a transitiontthat may delay the firing oftdhas latencyl(t), thentmust be disabled at leastl(t) time units before the expiration of the deadline ontd. In this paper, we discuss in detail two algorithms for generating transition latencies, and we show an application to a maintenance system.

This paper defines a reconfiguration method for the class of discrete-event systems (DES) that is subject to linear constraints as their control specifications. Some existing methods for enforcing these constraints make use of Petri-net P-invariants for controller synthesis. These methods are quite appealing because their computational complexity is much more tractable than most other methods for controller synthesis. However, a common limitation of all existing P-invariant-based control architectures for DES plants is the assumption that the linear constraints defining the control specification of the plant do not change over time. Here, we relax this assumption and allow the control specifications to change during controller runtime. Under certain assumptions on DES behavior, we automatically reconfigure the DES controller after the control specification is changed. In addition, if the current state of the controlled DES has become infeasible under the new control specification, we automatically generate a so-called plant reconfiguration procedure whose execution leads the system back to a feasible state. This reconfiguration procedure is optimal in that it seeks to minimize the cost of reconfiguration actions through an Integer Programming (IP) model. The objective function of the IP model can be used to generate reconfiguration solutions that meet some desired properties. Depending on the cost of each reconfiguration action, a minimum cost reconfiguration solution may use only actions contained in the current plant configuration (an internal response), or ask for a change in the plant configuration, for instance, by adding new resources (an external response), or a combination of both strategies. Finally, we illustrate our method by applying it to a hospital control system example. Note to Practitioners-This paper proposes a dynamic reconfiguration framework that can revise the operations of systems whose control requirements change over time. The proposed framework can be applied to systems that satisfy the following two assumptions. First, the behavior of the system under study is described in terms of a set of discrete states and events. Events will cause the system to transition between states. Second, the control requirements must be expressed by linear equalities and inequalities on the system states. Under these circumstances, the proposed framework can identify an optimal transition to a new control policy that satisfies the new control requirements. Moreover, the system under consideration will continue operating while this transition is taking place. One application of this method is in modifying hospital control strategies when a hospital experiences unexpected events. In this case, the hospital operations-such as patient handling, resource assignment, and procedure scheduling-can be represented by discrete state models (e.g., Petri nets). Constraints on these operations can be modeled by linear inequalities on hospital and patient state. Upon a change in the constraints, the proposed reconfiguration method revises the hospital control strategies. For example, a shift in the hospital service demands (e.g., an increase in the flow of patients to the hospital due to a mass casualty situation) can be translated to changes in the constraints. In this case, the hospital operations must be revised to accommodate the new constraints without disrupting the operation of the hospital. The reconfiguration method of this paper provides a framework for modeling the reconfiguration steps and for calculating the least cost reconfiguration solution.

We automatically synthesize supervisory controllers that force a system to perform a certain operation by a given deadline. The operation must be executed by a pre-specified delay λ with respect to the previous execution of the operation. We model both the controlled system and our control supervisors as time Petri nets. Given a target transition and a deadline, our supervisors disable net behaviors in which the firing of the target transition may miss the deadline. Our method is subject to a merge exclusion assumption on the structure of paths contained in a so-called net unfolding. If a control problem does not satisfy this assumption, we abandon supervisor generation. Preliminary empirical results show that our method is both relatively general and more tractable from a computational standpoint than most other real-time analysis methods.

We define supervisory controllers for enforcing deadlines on transition firings in time Petri nets. Given a target net transition t/sub d/, and a deadline /spl lambda/, we generate a controller that under broad assumptions forces t/sub d/ to fire every /spl lambda/ time units. Our supervisory controller is based on the notion of transition latency. The latency of a net transition is an upper bound on the time between the firing of that transition and the firing of t/sub d/. A transition is not allowed to fire when its latency is greater than the amount time left until t/sub d/ must fire. Our real-time supervisory controllers consist of two subnets, which are added to the controlled net in order to enforce deadline /spl lambda/ on the firing of t/sub d/. First, the clock subnet dynamically tracks the amount of time left until the expiration of /spl lambda/. As the deadline approaches, this subnet also indicates transitions that must be disabled because their latency has become greater than the time until the expiration of the deadline. When this happens, a supervisor subnet actually disables these transitions. These transitions are enabled again only after t/sub d/ has fired.

We outline a supervisory control method for enforcing deadlines in real-time systems modeled as time Petri nets. Given a time Petri net NscrT, a net transition td, and a deadline d, we generate supervisory controllers that force tdto fire at most d time units since the previous firing of td. Our method uses the unfolding of the ordinary (untimed) Petri net underlying NscrTin order to define control supervisors enforcing the deadline. The unfolding of a Petri net is an acyclic Petri net whose markings correspond to the markings of the original Petri net. An advantage of net unfoldings is that they show the causal relation among transition firings in the original Petri net. Using a net unfolding, we define a so-called latency for each transition in NscrT, which we assume to be live. The latency of a transition is an upper bound on the delay between the firing of that transition and the firing of td. Our supervisory controllers dynamically disable the firing of transitions whose latency is greater than the time left until the expiration of the deadline on td. Here we discuss the most crucial aspect of this method, namely the definition of transition latencies from net unfoldings

To date developers can exploit a wealth of existing languages and tools when designing and implementing Web applications; however, comprehensive and automated tools and techniques for producing these applications are still conspicuously lacking. Here we describe a framework for efficient production of Web applications, which synergistically integrates techniques for automatic code generation with some of the most recent technologies for Web development, such as the J2EE application server and XML. We also describe a general-purpose architecture for Web applications and our mockup-driven fast-prototyping methodology (MODFM), which is based on well-tried techniques such as rapid prototyping and mockup-driven software design. Finally, we discuss an example of a Web application developed with our methodology, a comprehensive university administration system that was recently deployed at a research university. Our initial experience with this system indicates that MODFM and related tools can provide dramatic improvements in developer productivity, while also enhancing the reliability of the resulting applications.

Compositional methods for Petri-net-based verification of concurrent systems are appealing because they allow the analysis of a complex system to be carried out in a piece-by-piece manner. An issue in compositional Petri-net analysis is the generation of a compact net from a labeled transition system (LTS) isomorphic to the reachability graph of the net. Several existing approaches for Petri-net generation use the concept of region, a subset of the original LTS; however, the computation of the regions in an LTS appears to be quite expensive. We report preliminary results on the generation of a Petri net from an LTS isomorphic to the net's reachability graph without requiring the computation of regions. We specifically introduce two algorithms for generating the place set and flow relation of a safe and live ordinary Petri net. The most complex of the two algorithms is nearly linear in the size of the input LTS.

Programs developed with object technologies have unique features that often make traditional testing methods inadequate. Consider, for instance, the dependence between the state of an object and the behavior of that object: The outcome of a method executed by an object often depends on the state of the object when the method is invoked. It is therefore crucial that techniques for testing of classes exercise class methods when the method's receiver is in different states. The state of an object at any given time depends on the sequence of messages received by the object up to that time. Thus, methods for testing object-oriented software should identify sequences of method invocations that are likely to uncover potential defects in the code under test. However, testing methods for traditional software do not provide this kind of information.

The design, implementation, and testing of virtual environments is complicated by the concurrency and real-time features of these systems. Therefore, the development of formal methods for modeling and analysis of virtual environments is highly desirable. In the past, Petri net models have led to good empirical results in the automatic verification of concurrent and real-time systems. We applied a timed extension of Petri nets to modeling and analysis of the CAVE/sup TM/ virtual environment at the University of Illinois at Chicago. We report on our time Petri net model and on empirical studies that we conducted with the Cabernet toolset from Politecnico di Milano. Our experiments uncovered a flaw in the way a shared buffer is used by CAVE processes. Due to an erroneous synchronization on the buffer, different CAVE walls can simultaneously display images based on different input information. We conclude from our empirical studies that Petri net-based tools can effectively support the development of reliable virtual environments.

The authors present LTP (Language of Timed Processes), a process-algebra-based specification language, for the specification of real-time applications. In addition to timing requirements involving the execution time of individual computations, LTP can specify timing constraints that are associated with process descriptions: periodic constraints and sporadic constraints. Periodic processes (e.g. sensors) are usually time-driven; sporadic processes are usually event-driven. In LTP common real-time constraints such as delays, deadlines, and timeouts can be modeled conveniently. They specifically introduce a new construct for modeling periodic behavior, which is quite common in real-time applications. They validate LTP specifications by translating from LTP to a kind of timed automata that is amenable to well-known model checking techniques. Although the models of LTP specifications, commonly known as timed transition systems, are usually infinite because of the presence of time, the translation results in a finite representation by which automatic verification is possible.

We present a first report on our PARTS toolset for the automated static analysis of real-time systems. The PARTS toolset is based upon a timed extension of Petri nets.

An emerging challenge for software engineering is the development of the methods and tools to aid design and analysis of concurrent and distributed software. Over the past few years, a number of analysis methods that focus on Ada tasking have been developed. Many of these methods are based on some form of reachability analysis, which has the advantage of being conceptually simple, but the disadvantage of being computationally expensive. We explore the effectiveness of various Petri net-based techniques for the automated deadlock analysis of Ada programs. Our experiments consider a variety of state space reduction methods both individually and in various combinations. The experiments are applied to a number of classical concurrent programs as well as a set of “real-world” programs. The results indicate that Petri net reduction and reduced state space generation are mutually beneficial techniques, and that combined approaches based on Petri net models are quite effective, compared to alternative analysis approaches.

Over the past few years, a number of research investigations have been initiated for static analysis of concurrent and distributed software. In this paper we report on experiments with various optimization techniques for reachability-based deadlock detection in Ada programs using Petri net models. Our experimental results show that various optimization techniques are mutually beneficial with respect to the effectiveness of the analysis.

The constrained expression approach to analysis of concurrent software systems can be used with a variety of design and programming languages and does not require a complete enumeration of the set of reachable states of the concurrent system. The construction of a toolset automating the main constrained expression analysis techniques and the results of experiments with that toolset are reported. The toolset is capable of carrying out completely automated analyses of a variety of concurrent systems, starting from source code in an Ada-like design language and producing system traces displaying the properties represented bv the analysts queries. The strengths and weaknesses of the toolset and the approach are assessed on both theoretical and empirical grounds.>