82,348 research outputs found
Some Theorems for Feed Forward Neural Networks
In this paper we introduce a new method which employs the concept of
"Orientation Vectors" to train a feed forward neural network and suitable for
problems where large dimensions are involved and the clusters are
characteristically sparse. The new method is not NP hard as the problem size
increases. We `derive' the method by starting from Kolmogrov's method and then
relax some of the stringent conditions. We show for most classification
problems three layers are sufficient and the network size depends on the number
of clusters. We prove as the number of clusters increase from N to N+dN the
number of processing elements in the first layer only increases by d(logN), and
are proportional to the number of classes, and the method is not NP hard.
Many examples are solved to demonstrate that the method of Orientation
Vectors requires much less computational effort than Radial Basis Function
methods and other techniques wherein distance computations are required, in
fact the present method increases logarithmically with problem size compared to
the Radial Basis Function method and the other methods which depend on distance
computations e.g statistical methods where probabilistic distances are
calculated. A practical method of applying the concept of Occum's razor to
choose between two architectures which solve the same classification problem
has been described. The ramifications of the above findings on the field of
Deep Learning have also been briefly investigated and we have found that it
directly leads to the existence of certain types of NN architectures which can
be used as a "mapping engine", which has the property of "invertibility", thus
improving the prospect of their deployment for solving problems involving Deep
Learning and hierarchical classification. The latter possibility has a lot of
future scope in the areas of machine learning and cloud computing.Comment: 15 pages 13 figure
From average case complexity to improper learning complexity
The basic problem in the PAC model of computational learning theory is to
determine which hypothesis classes are efficiently learnable. There is
presently a dearth of results showing hardness of learning problems. Moreover,
the existing lower bounds fall short of the best known algorithms.
The biggest challenge in proving complexity results is to establish hardness
of {\em improper learning} (a.k.a. representation independent learning).The
difficulty in proving lower bounds for improper learning is that the standard
reductions from -hard problems do not seem to apply in this
context. There is essentially only one known approach to proving lower bounds
on improper learning. It was initiated in (Kearns and Valiant 89) and relies on
cryptographic assumptions.
We introduce a new technique for proving hardness of improper learning, based
on reductions from problems that are hard on average. We put forward a (fairly
strong) generalization of Feige's assumption (Feige 02) about the complexity of
refuting random constraint satisfaction problems. Combining this assumption
with our new technique yields far reaching implications. In particular,
1. Learning 's is hard.
2. Agnostically learning halfspaces with a constant approximation ratio is
hard.
3. Learning an intersection of halfspaces is hard.Comment: 34 page
Minimal Synthesis of String To String Functions From Examples
We study the problem of synthesizing string to string transformations from a
set of input/output examples. The transformations we consider are expressed
using deterministic finite automata (DFA) that read pairs of letters, one
letter from the input and one from the output. The DFA corresponding to these
transformations have additional constraints, ensuring that each input string is
mapped to exactly one output string.
We suggest that, given a set of input/output examples, the smallest DFA
consistent with the examples is a good candidate for the transformation the
user was expecting. We therefore study the problem of, given a set of examples,
finding a minimal DFA consistent with the examples and satisfying the
functionality and totality constraints mentioned above.
We prove that, in general, this problem (the corresponding decision problem)
is NP-complete. This is unlike the standard DFA minimization problem which can
be solved in polynomial time. We provide several NP-hardness proofs that show
the hardness of multiple (independent) variants of the problem.
Finally, we propose an algorithm for finding the minimal DFA consistent with
input/output examples, that uses a reduction to SMT solvers. We implemented the
algorithm, and used it to evaluate the likelihood that the minimal DFA indeed
corresponds to the DFA expected by the user.Comment: SYNT 201
Why Philosophers Should Care About Computational Complexity
One might think that, once we know something is computable, how efficiently
it can be computed is a practical question with little further philosophical
importance. In this essay, I offer a detailed case that one would be wrong. In
particular, I argue that computational complexity theory---the field that
studies the resources (such as time, space, and randomness) needed to solve
computational problems---leads to new perspectives on the nature of
mathematical knowledge, the strong AI debate, computationalism, the problem of
logical omniscience, Hume's problem of induction, Goodman's grue riddle, the
foundations of quantum mechanics, economic rationality, closed timelike curves,
and several other topics of philosophical interest. I end by discussing aspects
of complexity theory itself that could benefit from philosophical analysis.Comment: 58 pages, to appear in "Computability: G\"odel, Turing, Church, and
beyond," MIT Press, 2012. Some minor clarifications and corrections; new
references adde
- …