#1205

Committed 26 Jan 2015 12:57PM UTC coverage: 14.409% (+0.005%) from 14.404%

Build # #1205

Build Type

push

Committed by David Ray

Commit Message

Merge pull request #168 from cogmission/network_api_work

testing the RNG is not part of the scope

Run Details

718 of 4983 relevant lines covered (14.41%)

0.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/numenta/nupic/encoders/MultiEncoder.java

/* ---------------------------------------------------------------------
 * Numenta Platform for Intelligent Computing (NuPIC)
 * Copyright (C) 2014, Numenta, Inc.  Unless you have an agreement
 * with Numenta, Inc., for a separate license for this software code, the
 * following terms and conditions apply:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see http://www.gnu.org/licenses.
 *
 * http://numenta.org/licenses/
 * ---------------------------------------------------------------------
 */

package org.numenta.nupic.encoders;

import gnu.trove.map.TIntObjectMap;
import gnu.trove.map.TObjectIntMap;
import gnu.trove.map.hash.TIntObjectHashMap;
import gnu.trove.map.hash.TObjectIntHashMap;
import org.numenta.nupic.Parameters;
import org.numenta.nupic.util.Tuple;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * A MultiEncoder encodes a dictionary or object with
 * multiple components. A MultiEncode contains a number
 * of sub-encoders, each of which encodes a separate component.
 * 
 * @see Encoder
 * @see EncoderResult
 * @see Parameters
 * 
 * @author wlmiller
 */
public class MultiEncoder extends Encoder<Object> {
        protected int ncategories;
        
        protected TObjectIntMap<String> categoryToIndex = new TObjectIntHashMap<String>();
        protected TIntObjectMap<String> indexToCategory = new TIntObjectHashMap<String>();
        
        protected List<Tuple> categoryList;
        
        protected int width;
        
        /**
         * Constructs a new {@code MultiEncoder}
         */
        private MultiEncoder() {}
        
        /**
         * Returns a builder for building MultiEncoders. 
         * This builder may be reused to produce multiple builders
         * 
         * @return a {@code MultiEncoder.Builder}
         */
        public static Encoder.Builder<MultiEncoder.Builder, MultiEncoder> builder() {
                return new MultiEncoder.Builder();
        }

        public void init() {
                encoders = new LinkedHashMap<EncoderTuple, List<EncoderTuple>>();
                encoders.put(new EncoderTuple("", this, 0), new ArrayList<EncoderTuple>());
        }
        
        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public void setFieldStats(String fieldName, Map<String, Double> fieldStatistics) {
                for (EncoderTuple t : getEncoders(this)) {
                        String name = t.getName();
                        Encoder encoder = t.getEncoder();
                        encoder.setFieldStats(name, fieldStatistics);
                }
        }
        
        /**
         * {@inheritDoc}
         */
        @SuppressWarnings({ "rawtypes", "unchecked" })
        @Override
        public void encodeIntoArray(Object input, int[] output) {
                for (EncoderTuple t : getEncoders(this)) {
                        String name = t.getName();
                        Encoder encoder = t.getEncoder();
                        int offset = t.getOffset();
                        
                        int[] tempArray = new int[encoder.getWidth()];
                        encoder.encodeIntoArray(getInputValue(input, name), tempArray);
                        
                        for (int i = 0; i < tempArray.length; i++) {
                                output[i + offset] = tempArray[i];
                        }
                }
        }
        
        @SuppressWarnings({ "rawtypes", "unchecked" })
        public int[] encodeField(String fieldName, Object value) {
                for (EncoderTuple t : getEncoders(this)) {
                        String name = t.getName();
                        Encoder encoder = t.getEncoder();
                        
                        if (name.equals(fieldName)) {
                                return encoder.encode(value);
                        }
                }
                return new int[]{};
        }
        
        @SuppressWarnings({ "rawtypes", "unchecked" })
        public List<int[]> encodeEachField(Object input) {
                List<int[]> encodings = new ArrayList<int[]>();
                
                for (EncoderTuple t : getEncoders(this)) {
                        String name = t.getName();
                        Encoder encoder = t.getEncoder();
                        
                        encodings.add(encoder.encode(getInputValue(input, name)));
                }
                
                return encodings;
        }
        
        @SuppressWarnings({ "rawtypes", "unchecked" })
        public void addEncoder(String name, Encoder child) {
                super.addEncoder(this, name, child, width);
                
                for (Object d : child.getDescription()) {
                        Tuple dT = (Tuple) d;
                        description.add(new Tuple(2, dT.get(0), (int)dT.get(1) + getWidth()));
                }
                width += child.getWidth();
        }
        
        @SuppressWarnings("rawtypes")
        public void addMultipleEncoders(Map<String, Map<String, Object>> fieldEncodings) {
                // Sort the encoders so that they end up in a controlled order
                List<String> sortedFields = new ArrayList<String>(fieldEncodings.keySet());
                Collections.sort(sortedFields);
                
                for (String field : sortedFields) {
                        Map<String, Object> params = fieldEncodings.get(field);
                        
                        if (!params.containsKey("fieldname")) {
                                throw new IllegalArgumentException("Missing fieldname for encoder " + field);
                        }
                        String fieldName = (String) params.get("fieldname");
                        
                        if (!params.containsKey("type")) {
                                throw new IllegalArgumentException("Missing type for encoder " + field);
                        }
                        String encoderName = (String) params.get("type");
                        
                        Encoder.Builder builder = getBuilder(encoderName);
                        
                        for (String param : params.keySet()) {
                                if (!param.equals("fieldname") && !param.equals("type")) {
                                        setValue(builder, param, params.get(param));
                                }
                        }
                        
                        Encoder encoder = (Encoder)builder.build();
                        this.addEncoder(fieldName, encoder);
                }
        }
        
        private Encoder.Builder<?,?> getBuilder(String encoderName) {
                switch(encoderName) {
                        case "CategoryEncoder":
                                return CategoryEncoder.builder();
                        case "CoordinateEncoder":
                                return CoordinateEncoder.builder();
                        case "GeospatialCoordinateEncoder":
                                return GeospatialCoordinateEncoder.geobuilder();
                        case "LogEncoder":
                                return LogEncoder.builder();
                        case "PassThroughEncoder":
                                return PassThroughEncoder.builder();
                        case "ScalarEncoder":
                                return ScalarEncoder.builder();
                        case "SparsePassThroughEncoder":
                                return SparsePassThroughEncoder.sparseBuilder();
            case "SDRCategoryEncoder":
                return SDRCategoryEncoder.builder();
                        default:
                                throw new IllegalArgumentException("Invalid encoder: " + encoderName);
                }
        }
        
        @SuppressWarnings({ "rawtypes", "unchecked" })
        private void setValue(Encoder.Builder builder, String param, Object value)  {
                switch(param) {
                case "n":
                        builder.n((int) value);
                        break;
                case "w":
                        builder.w((int) value);
                        break;
                case "verbosity":
                        builder.verbosity((int) value);
                        break;
                case "minVal":
                        builder.minVal((double) value);
                        break;
                case "maxVal":
                        builder.maxVal((double) value);
                        break;        
                case "radius":
                        builder.radius((double) value);
                        break;
                case "resolution":
                        builder.resolution((double) value);
                        break;
                case "periodic":
                        builder.periodic((boolean) value);
                        break;
                case "clipInput":
                        builder.clipInput((boolean) value);
                        break;
                case "forced":
                        builder.forced((boolean) value);
                        break;
                case "name":
                        builder.name((String) value);
                        break;
                case "categoryList":
                        ((CategoryEncoder.Builder) builder).categoryList((List<String>) value);
                        break;
                default:
                        throw new IllegalArgumentException("Invalid parameter: " + param);
                }
        }

        @Override
        public int getWidth() {
                return width;
        }
        
        @Override
        public int getN() {
                return width;
        }
        
        @Override
        public int getW() {
                return width;
        }
        
        @Override
        public String getName() {
                if (name == null) return "";
                else return name;
        }

        @Override
        public boolean isDelta() {
                return false;
        }

        @SuppressWarnings("rawtypes")
        @Override
        public void setLearning(boolean learningEnabled) {
                for (EncoderTuple t : getEncoders(this)) {
                        Encoder encoder = t.getEncoder();
                        encoder.setLearningEnabled(learningEnabled);        
                }
        }
    
        @Override
        public <S> List<S> getBucketValues(Class<S> returnType) {
                return null;
        }
        
    /**
         * Returns a {@link EncoderBuilder} for constructing {@link MultiEncoder}s
         * 
         * The base class architecture is put together in such a way where boilerplate
         * initialization can be kept to a minimum for implementing subclasses, while avoiding
         * the mistake-proneness of extremely long argument lists.
         * 
         */
        public static class Builder extends Encoder.Builder<MultiEncoder.Builder, MultiEncoder> {
                private Builder() {}

                @Override
                public MultiEncoder build() {
                        //Must be instantiated so that super class can initialize 
                        //boilerplate variables.
                        encoder = new MultiEncoder();
                        
                        //Call super class here
                        super.build();
                        
                        ////////////////////////////////////////////////////////
                        //  Implementing classes would do setting of specific //
                        //  vars here together with any sanity checking       //
                        ////////////////////////////////////////////////////////

                        //Call init
                        ((MultiEncoder)encoder).init();
                        
                        return (MultiEncoder)encoder;
                }
        }
}

1	/* ---------------------------------------------------------------------
2	* Numenta Platform for Intelligent Computing (NuPIC)
3	* Copyright (C) 2014, Numenta, Inc. Unless you have an agreement
4	* with Numenta, Inc., for a separate license for this software code, the
5	* following terms and conditions apply:
6	*
7	* This program is free software: you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License version 3 as
9	* published by the Free Software Foundation.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14	* See the GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program. If not, see http://www.gnu.org/licenses.
18	*
19	* http://numenta.org/licenses/
20	* ---------------------------------------------------------------------
21	*/
22
23	package org.numenta.nupic.encoders;
24
25	import gnu.trove.map.TIntObjectMap;
26	import gnu.trove.map.TObjectIntMap;
27	import gnu.trove.map.hash.TIntObjectHashMap;
28	import gnu.trove.map.hash.TObjectIntHashMap;
29	import org.numenta.nupic.Parameters;
30	import org.numenta.nupic.util.Tuple;
31
32	import java.util.ArrayList;
33	import java.util.Collections;
34	import java.util.LinkedHashMap;
35	import java.util.List;
36	import java.util.Map;
37
38	/**
39	* A MultiEncoder encodes a dictionary or object with
40	* multiple components. A MultiEncode contains a number
41	* of sub-encoders, each of which encodes a separate component.
42	*
43	* @see Encoder
44	* @see EncoderResult
45	* @see Parameters
46	*
47	* @author wlmiller
48	*/
49	public class MultiEncoder extends Encoder<Object> {
50	protected int ncategories;
51
52	protected TObjectIntMap<String> categoryToIndex = new TObjectIntHashMap<String>();	×
53	protected TIntObjectMap<String> indexToCategory = new TIntObjectHashMap<String>();	×
54
55	protected List<Tuple> categoryList;
56
57	protected int width;
58
59	/**
60	* Constructs a new {@code MultiEncoder}
61	*/
62	private MultiEncoder() {}	×
63
64	/**
65	* Returns a builder for building MultiEncoders.
66	* This builder may be reused to produce multiple builders
67	*
68	* @return a {@code MultiEncoder.Builder}
69	*/
70	public static Encoder.Builder<MultiEncoder.Builder, MultiEncoder> builder() {
71	return new MultiEncoder.Builder();	×
72	}
73
74	public void init() {
75	encoders = new LinkedHashMap<EncoderTuple, List<EncoderTuple>>();	×
76	encoders.put(new EncoderTuple("", this, 0), new ArrayList<EncoderTuple>());	×
77	}	×
78
79	@SuppressWarnings({ "unchecked", "rawtypes" })
80	@Override
81	public void setFieldStats(String fieldName, Map<String, Double> fieldStatistics) {
82	for (EncoderTuple t : getEncoders(this)) {	×
83	String name = t.getName();	×
84	Encoder encoder = t.getEncoder();	×
85	encoder.setFieldStats(name, fieldStatistics);	×
86	}	×
87	}	×
88
89	/**
90	* {@inheritDoc}
91	*/
92	@SuppressWarnings({ "rawtypes", "unchecked" })
93	@Override
94	public void encodeIntoArray(Object input, int[] output) {
95	for (EncoderTuple t : getEncoders(this)) {	×
96	String name = t.getName();	×
97	Encoder encoder = t.getEncoder();	×
98	int offset = t.getOffset();	×
99
100	int[] tempArray = new int[encoder.getWidth()];	×
101	encoder.encodeIntoArray(getInputValue(input, name), tempArray);	×
102
103	for (int i = 0; i < tempArray.length; i++) {	×
104	output[i + offset] = tempArray[i];	×
105	}
106	}	×
107	}	×
108
109	@SuppressWarnings({ "rawtypes", "unchecked" })
110	public int[] encodeField(String fieldName, Object value) {
111	for (EncoderTuple t : getEncoders(this)) {	×
112	String name = t.getName();	×
113	Encoder encoder = t.getEncoder();	×
114
115	if (name.equals(fieldName)) {	×
116	return encoder.encode(value);	×
117	}
118	}	×
119	return new int[]{};	×
120	}
121
122	@SuppressWarnings({ "rawtypes", "unchecked" })
123	public List<int[]> encodeEachField(Object input) {
124	List<int[]> encodings = new ArrayList<int[]>();	×
125
126	for (EncoderTuple t : getEncoders(this)) {	×
127	String name = t.getName();	×
128	Encoder encoder = t.getEncoder();	×
129
130	encodings.add(encoder.encode(getInputValue(input, name)));	×
131	}	×
132
133	return encodings;	×
134	}
135
136	@SuppressWarnings({ "rawtypes", "unchecked" })
137	public void addEncoder(String name, Encoder child) {
138	super.addEncoder(this, name, child, width);	×
139
140	for (Object d : child.getDescription()) {	×
141	Tuple dT = (Tuple) d;	×
142	description.add(new Tuple(2, dT.get(0), (int)dT.get(1) + getWidth()));	×
143	}	×
144	width += child.getWidth();	×
145	}	×
146
147	@SuppressWarnings("rawtypes")
148	public void addMultipleEncoders(Map<String, Map<String, Object>> fieldEncodings) {
149	// Sort the encoders so that they end up in a controlled order
150	List<String> sortedFields = new ArrayList<String>(fieldEncodings.keySet());	×
151	Collections.sort(sortedFields);	×
152
153	for (String field : sortedFields) {	×
154	Map<String, Object> params = fieldEncodings.get(field);	×
155
156	if (!params.containsKey("fieldname")) {	×
157	throw new IllegalArgumentException("Missing fieldname for encoder " + field);	×
158	}
159	String fieldName = (String) params.get("fieldname");	×
160
161	if (!params.containsKey("type")) {	×
162	throw new IllegalArgumentException("Missing type for encoder " + field);	×
163	}
164	String encoderName = (String) params.get("type");	×
165
166	Encoder.Builder builder = getBuilder(encoderName);	×
167
168	for (String param : params.keySet()) {	×
169	if (!param.equals("fieldname") && !param.equals("type")) {	×
170	setValue(builder, param, params.get(param));	×
171	}
172	}	×
173
174	Encoder encoder = (Encoder)builder.build();	×
175	this.addEncoder(fieldName, encoder);	×
176	}	×
177	}	×
178
179	private Encoder.Builder<?,?> getBuilder(String encoderName) {
180	switch(encoderName) {	×
181	case "CategoryEncoder":
182	return CategoryEncoder.builder();	×
183	case "CoordinateEncoder":
184	return CoordinateEncoder.builder();	×
185	case "GeospatialCoordinateEncoder":
186	return GeospatialCoordinateEncoder.geobuilder();	×
187	case "LogEncoder":
188	return LogEncoder.builder();	×
189	case "PassThroughEncoder":
190	return PassThroughEncoder.builder();	×
191	case "ScalarEncoder":
192	return ScalarEncoder.builder();	×
193	case "SparsePassThroughEncoder":
194	return SparsePassThroughEncoder.sparseBuilder();	×
195	case "SDRCategoryEncoder":
196	return SDRCategoryEncoder.builder();	×
197	default:
198	throw new IllegalArgumentException("Invalid encoder: " + encoderName);	×
199	}
200	}
201
202	@SuppressWarnings({ "rawtypes", "unchecked" })
203	private void setValue(Encoder.Builder builder, String param, Object value) {
204	switch(param) {	×
205	case "n":
206	builder.n((int) value);	×
207	break;	×
208	case "w":
209	builder.w((int) value);	×
210	break;	×
211	case "verbosity":
212	builder.verbosity((int) value);	×
213	break;	×
214	case "minVal":
215	builder.minVal((double) value);	×
216	break;	×
217	case "maxVal":
218	builder.maxVal((double) value);	×
219	break;	×
220	case "radius":
221	builder.radius((double) value);	×
222	break;	×
223	case "resolution":
224	builder.resolution((double) value);	×
225	break;	×
226	case "periodic":
227	builder.periodic((boolean) value);	×
228	break;	×
229	case "clipInput":
230	builder.clipInput((boolean) value);	×
231	break;	×
232	case "forced":
233	builder.forced((boolean) value);	×
234	break;	×
235	case "name":
236	builder.name((String) value);	×
237	break;	×
238	case "categoryList":
239	((CategoryEncoder.Builder) builder).categoryList((List<String>) value);	×
240	break;	×
241	default:
242	throw new IllegalArgumentException("Invalid parameter: " + param);	×
243	}
244	}	×
245
246	@Override
247	public int getWidth() {
248	return width;	×
249	}
250
251	@Override
252	public int getN() {
253	return width;	×
254	}
255
256	@Override
257	public int getW() {
258	return width;	×
259	}
260
261	@Override
262	public String getName() {
263	if (name == null) return "";	×
264	else return name;	×
265	}
266
267	@Override
268	public boolean isDelta() {
269	return false;	×
270	}
271
272	@SuppressWarnings("rawtypes")
273	@Override
274	public void setLearning(boolean learningEnabled) {
275	for (EncoderTuple t : getEncoders(this)) {	×
276	Encoder encoder = t.getEncoder();	×
277	encoder.setLearningEnabled(learningEnabled);	×
278	}	×
279	}	×
280
281	@Override
282	public <S> List<S> getBucketValues(Class<S> returnType) {
283	return null;	×
284	}
285
286	/**
287	* Returns a {@link EncoderBuilder} for constructing {@link MultiEncoder}s
288	*
289	* The base class architecture is put together in such a way where boilerplate
290	* initialization can be kept to a minimum for implementing subclasses, while avoiding
291	* the mistake-proneness of extremely long argument lists.
292	*
293	*/
294	public static class Builder extends Encoder.Builder<MultiEncoder.Builder, MultiEncoder> {
295	private Builder() {}	×
296
297	@Override
298	public MultiEncoder build() {
299	//Must be instantiated so that super class can initialize
300	//boilerplate variables.
301	encoder = new MultiEncoder();	×
302
303	//Call super class here
304	super.build();	×
305
306	////////////////////////////////////////////////////////
307	// Implementing classes would do setting of specific //
308	// vars here together with any sanity checking //
309	////////////////////////////////////////////////////////
310
311	//Call init
312	((MultiEncoder)encoder).init();	×
313
314	return (MultiEncoder)encoder;	×
315	}
316	}
317	}

numenta / htm.java / #1205

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous