Hello All,

I am using PyCharm IDE and anaconda (python 3.5.2). I have installed theano 
using conda. I tested with a small program in PyCharm as well as Spyder. 
The program runs well in spyder but gives issues in PyCharm IDE. I tried to 
install theano package in pyCharm IDE, but doesn't help. Below is the error 
which I get in pyCharm:


C:\Users\Bhavana\Anaconda3\python.exe 
C:/Users/Bhavana/PycharmProjects/untitled/1.py
===============================
00001 #include <Python.h>
00002 #include <iostream>
00003 #include "theano_mod_helper.h"
00004 #include <math.h>
00005 #include <numpy/arrayobject.h>
00006 #include <numpy/arrayscalars.h>
00007 #include <vector>
00008 #include <algorithm>
00009 //////////////////////
00010 ////  Support Code
00011 //////////////////////
00012 
00013    namespace {
00014    struct __struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707 {
00015        PyObject* __ERROR;
00016 
00017        PyObject* storage_V3;
00018 PyObject* storage_V5;
00019 PyObject* storage_V1;
00020        
00021 
00022        __struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707() {
00023            // This is only somewhat safe because we:
00024            //  1) Are not a virtual class
00025            //  2) Do not use any virtual classes in the members
00026            //  3) Deal with mostly POD and pointers
00027 
00028            // If this changes, we would have to revise this, but for
00029            // now I am tired of chasing segfaults because
00030            // initialization code had an error and some pointer has
00031            // a junk value.
00032            memset(this, 0, sizeof(*this));
00033        }
00034        ~__struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707(void) {
00035            cleanup();
00036        }
00037 
00038        int init(PyObject* __ERROR, PyObject* storage_V3, PyObject* 
storage_V5, PyObject* storage_V1) {
00039            Py_XINCREF(storage_V3);
00040 Py_XINCREF(storage_V5);
00041 Py_XINCREF(storage_V1);
00042            this->storage_V3 = storage_V3;
00043 this->storage_V5 = storage_V5;
00044 this->storage_V1 = storage_V1;
00045            
00046 
00047 
00048 
00049 
00050            this->__ERROR = __ERROR;
00051            return 0;
00052        }
00053        void cleanup(void) {
00054            __label_1:
00055 
00056 double __DUMMY_1;
00057 __label_3:
00058 
00059 double __DUMMY_3;
00060 __label_5:
00061 
00062 double __DUMMY_5;
00063 __label_8:
00064 
00065 double __DUMMY_8;
00066 
00067            Py_XDECREF(this->storage_V3);
00068 Py_XDECREF(this->storage_V5);
00069 Py_XDECREF(this->storage_V1);
00070        }
00071        int run(void) {
00072            int __failure = 0;
00073            
00074    PyObject* py_V1;
00075    
00076        PyArrayObject* V1;
00077        
00078            typedef npy_float64 dtype_V1;
00079            
00080    PyObject* py_V3;
00081    
00082        PyArrayObject* V3;
00083        
00084            typedef npy_float64 dtype_V3;
00085            
00086    PyObject* py_V5;
00087    
00088        PyArrayObject* V5;
00089        
00090            typedef npy_float64 dtype_V5;
00091            
00092 {
00093 
00094    py_V1 = Py_None;
00095    {Py_XINCREF(py_V1);}
00096    
00097        V1 = NULL;
00098        
00099 {
00100 
00101    py_V3 = PyList_GET_ITEM(storage_V3, 0);
00102    {Py_XINCREF(py_V3);}
00103    
00104            V3 = NULL;
00105            if (py_V3 == Py_None) {
00106                // We can either fail here or set V3 to NULL and rely 
on Ops
00107                // using tensors to handle the NULL case, but if they 
fail to do so
00108                // they'll end up with nasty segfaults, so this is 
public service.
00109                PyErr_SetString(PyExc_ValueError, "expected an 
ndarray, not None");
00110                {
00111        __failure = 4;
00112        if (!PyErr_Occurred()) {
00113            PyErr_SetString(PyExc_RuntimeError,
00114                "Unexpected error in an Op's C code. "
00115                "No Python exception was set.");
00116            }
00117        goto __label_4;}
00118            }
00119            if (!PyArray_Check(py_V3)) {
00120                PyErr_SetString(PyExc_ValueError, "expected an 
ndarray");
00121                {
00122        __failure = 4;
00123        if (!PyErr_Occurred()) {
00124            PyErr_SetString(PyExc_RuntimeError,
00125                "Unexpected error in an Op's C code. "
00126                "No Python exception was set.");
00127            }
00128        goto __label_4;}
00129            }
00130            // We expect NPY_FLOAT64
00131            if (!PyArray_ISALIGNED((PyArrayObject*) py_V3)) {
00132                PyArrayObject * tmp = (PyArrayObject*) py_V3;
00133                PyErr_Format(PyExc_NotImplementedError,
00134                             "expected an aligned array of type %ld "
00135                             "(NPY_FLOAT64), got non-aligned array of 
type %ld"
00136                             " with %ld dimensions, with 3 last dims "
00137                             "%ld, %ld, %ld"
00138                             " and 3 last strides %ld %ld, %ld.",
00139                             (long int) NPY_FLOAT64,
00140                             (long int) PyArray_TYPE((PyArrayObject*) 
py_V3),
00141                             (long int) PyArray_NDIM(tmp),
00142                             (long int) (PyArray_NDIM(tmp) >= 3 ?
00143            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
00144                             (long int) (PyArray_NDIM(tmp) >= 2 ?
00145            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
00146                             (long int) (PyArray_NDIM(tmp) >= 1 ?
00147            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
00148                             (long int) (PyArray_NDIM(tmp) >= 3 ?
00149            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
00150                             (long int) (PyArray_NDIM(tmp) >= 2 ?
00151            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
00152                             (long int) (PyArray_NDIM(tmp) >= 1 ?
00153            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
00154            );
00155                {
00156        __failure = 4;
00157        if (!PyErr_Occurred()) {
00158            PyErr_SetString(PyExc_RuntimeError,
00159                "Unexpected error in an Op's C code. "
00160                "No Python exception was set.");
00161            }
00162        goto __label_4;}
00163            }
00164            // This is a TypeError to be consistent with DEBUG_MODE
00165            // Note: DEBUG_MODE also tells the name of the container
00166            if (PyArray_TYPE((PyArrayObject*) py_V3) != NPY_FLOAT64) {
00167                PyErr_Format(PyExc_TypeError,
00168                             "expected type_num %d (NPY_FLOAT64) got 
%d",
00169                             NPY_FLOAT64, 
PyArray_TYPE((PyArrayObject*) py_V3));
00170                {
00171        __failure = 4;
00172        if (!PyErr_Occurred()) {
00173            PyErr_SetString(PyExc_RuntimeError,
00174                "Unexpected error in an Op's C code. "
00175                "No Python exception was set.");
00176            }
00177        goto __label_4;}
00178            }
00179            
00180        V3 = (PyArrayObject*)(py_V3);
00181        Py_XINCREF(V3);
00182        
00183 {
00184 
00185    py_V5 = PyList_GET_ITEM(storage_V5, 0);
00186    {Py_XINCREF(py_V5);}
00187    
00188            V5 = NULL;
00189            if (py_V5 == Py_None) {
00190                // We can either fail here or set V5 to NULL and rely 
on Ops
00191                // using tensors to handle the NULL case, but if they 
fail to do so
00192                // they'll end up with nasty segfaults, so this is 
public service.
00193                PyErr_SetString(PyExc_ValueError, "expected an 
ndarray, not None");
00194                {
00195        __failure = 6;
00196        if (!PyErr_Occurred()) {
00197            PyErr_SetString(PyExc_RuntimeError,
00198                "Unexpected error in an Op's C code. "
00199                "No Python exception was set.");
00200            }
00201        goto __label_6;}
00202            }
00203            if (!PyArray_Check(py_V5)) {
00204                PyErr_SetString(PyExc_ValueError, "expected an 
ndarray");
00205                {
00206        __failure = 6;
00207        if (!PyErr_Occurred()) {
00208            PyErr_SetString(PyExc_RuntimeError,
00209                "Unexpected error in an Op's C code. "
00210                "No Python exception was set.");
00211            }
00212        goto __label_6;}
00213            }
00214            // We expect NPY_FLOAT64
00215            if (!PyArray_ISALIGNED((PyArrayObject*) py_V5)) {
00216                PyArrayObject * tmp = (PyArrayObject*) py_V5;
00217                PyErr_Format(PyExc_NotImplementedError,
00218                             "expected an aligned array of type %ld "
00219                             "(NPY_FLOAT64), got non-aligned array of 
type %ld"
00220                             " with %ld dimensions, with 3 last dims "
00221                             "%ld, %ld, %ld"
00222                             " and 3 last strides %ld %ld, %ld.",
00223                             (long int) NPY_FLOAT64,
00224                             (long int) PyArray_TYPE((PyArrayObject*) 
py_V5),
00225                             (long int) PyArray_NDIM(tmp),
00226                             (long int) (PyArray_NDIM(tmp) >= 3 ?
00227            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
00228                             (long int) (PyArray_NDIM(tmp) >= 2 ?
00229            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
00230                             (long int) (PyArray_NDIM(tmp) >= 1 ?
00231            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
00232                             (long int) (PyArray_NDIM(tmp) >= 3 ?
00233            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
00234                             (long int) (PyArray_NDIM(tmp) >= 2 ?
00235            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
00236                             (long int) (PyArray_NDIM(tmp) >= 1 ?
00237            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
00238            );
00239                {
00240        __failure = 6;
00241        if (!PyErr_Occurred()) {
00242            PyErr_SetString(PyExc_RuntimeError,
00243                "Unexpected error in an Op's C code. "
00244                "No Python exception was set.");
00245            }
00246        goto __label_6;}
00247            }
00248            // This is a TypeError to be consistent with DEBUG_MODE
00249            // Note: DEBUG_MODE also tells the name of the container
00250            if (PyArray_TYPE((PyArrayObject*) py_V5) != NPY_FLOAT64) {
00251                PyErr_Format(PyExc_TypeError,
00252                             "expected type_num %d (NPY_FLOAT64) got 
%d",
00253                             NPY_FLOAT64, 
PyArray_TYPE((PyArrayObject*) py_V5));
00254                {
00255        __failure = 6;
00256        if (!PyErr_Occurred()) {
00257            PyErr_SetString(PyExc_RuntimeError,
00258                "Unexpected error in an Op's C code. "
00259                "No Python exception was set.");
00260            }
00261        goto __label_6;}
00262            }
00263            
00264        V5 = (PyArrayObject*)(py_V5);
00265        Py_XINCREF(V5);
00266        
00267 {
00268 // Op class Elemwise
00269 
00270        npy_float64* V3_iter;
00271        
00272        npy_float64* V5_iter;
00273        
00274 
00275 
00276        npy_float64* V1_iter;
00277        
00278    {
00279        npy_intp dims[0];
00280        //npy_intp* dims = (npy_intp*)malloc(0 * sizeof(npy_intp));
00281        
00282        if (!V1) {
00283            V1 = (PyArrayObject*)PyArray_EMPTY(0, dims,
00284                                                    NPY_FLOAT64,
00285                                                    0);
00286        }
00287        else {
00288            PyArray_Dims new_dims;
00289            new_dims.len = 0;
00290            new_dims.ptr = dims;
00291            PyObject* success = PyArray_Resize(V1, &new_dims, 0, 
NPY_CORDER);
00292            if (!success) {
00293                // If we can't resize the ndarray we have we can 
allocate a new one.
00294                PyErr_Clear();
00295                Py_XDECREF(V1);
00296                V1 = (PyArrayObject*)PyArray_EMPTY(0, dims, 
NPY_FLOAT64, 0);
00297            }
00298        }
00299        if (!V1) {
00300            {
00301        __failure = 7;
00302        if (!PyErr_Occurred()) {
00303            PyErr_SetString(PyExc_RuntimeError,
00304                "Unexpected error in an Op's C code. "
00305                "No Python exception was set.");
00306            }
00307        goto __label_7;}
00308        }
00309    }
00310    
00311 
00312                {
00313                  
00314                  V3_iter = (npy_float64*)(PyArray_DATA(V3));
00315 V5_iter = (npy_float64*)(PyArray_DATA(V5));
00316 V1_iter = (npy_float64*)(PyArray_DATA(V1));
00317 
00318                  npy_float64& V3_i = *V3_iter;
00319 npy_float64& V5_i = *V5_iter;
00320 npy_float64& V1_i = *V1_iter;
00321 
00322                  V1_i = V3_i * V5_i;
00323                  
00324                }
00325                __label_7:
00326 
00327 double __DUMMY_7;
00328 
00329 }
00330 __label_6:
00331 
00332        if (V5) {
00333            Py_XDECREF(V5);
00334        }
00335        
00336    {Py_XDECREF(py_V5);}
00337    
00338 double __DUMMY_6;
00339 
00340 }
00341 __label_4:
00342 
00343        if (V3) {
00344            Py_XDECREF(V3);
00345        }
00346        
00347    {Py_XDECREF(py_V3);}
00348    
00349 double __DUMMY_4;
00350 
00351 }
00352 __label_2:
00353 
00354    if (!__failure) {
00355      
00356        {Py_XDECREF(py_V1);}
00357        if (!V1) {
00358            Py_INCREF(Py_None);
00359            py_V1 = Py_None;
00360        }
00361        else if ((void*)py_V1 != (void*)V1) {
00362            py_V1 = (PyObject*)V1;
00363        }
00364 
00365        {Py_XINCREF(py_V1);}
00366 
00367        if (V1 && !PyArray_ISALIGNED((PyArrayObject*) py_V1)) {
00368            PyErr_Format(PyExc_NotImplementedError,
00369                         "c_sync: expected an aligned array, got 
non-aligned array of type %ld"
00370                         " with %ld dimensions, with 3 last dims "
00371                         "%ld, %ld, %ld"
00372                         " and 3 last strides %ld %ld, %ld.",
00373                         (long int) PyArray_TYPE((PyArrayObject*) 
py_V1),
00374                         (long int) PyArray_NDIM(V1),
00375                         (long int) (PyArray_NDIM(V1) >= 3 ?
00376        PyArray_DIMS(V1)[PyArray_NDIM(V1)-3] : -1),
00377                         (long int) (PyArray_NDIM(V1) >= 2 ?
00378        PyArray_DIMS(V1)[PyArray_NDIM(V1)-2] : -1),
00379                         (long int) (PyArray_NDIM(V1) >= 1 ?
00380        PyArray_DIMS(V1)[PyArray_NDIM(V1)-1] : -1),
00381                         (long int) (PyArray_NDIM(V1) >= 3 ?
00382        PyArray_STRIDES(V1)[PyArray_NDIM(V1)-3] : -1),
00383                         (long int) (PyArray_NDIM(V1) >= 2 ?
00384        PyArray_STRIDES(V1)[PyArray_NDIM(V1)-2] : -1),
00385                         (long int) (PyArray_NDIM(V1) >= 1 ?
00386        PyArray_STRIDES(V1)[PyArray_NDIM(V1)-1] : -1)
00387        );
00388            {
00389        __failure = 2;
00390        if (!PyErr_Occurred()) {
00391            PyErr_SetString(PyExc_RuntimeError,
00392                "Unexpected error in an Op's C code. "
00393                "No Python exception was set.");
00394            }
00395        goto __label_2;}
00396        }
00397        
00398      PyObject* old = PyList_GET_ITEM(storage_V1, 0);
00399      {Py_XINCREF(py_V1);}
00400      PyList_SET_ITEM(storage_V1, 0, py_V1);
00401      {Py_XDECREF(old);}
00402    }
00403    
00404        if (V1) {
00405            Py_XDECREF(V1);
00406        }
00407        
00408    {Py_XDECREF(py_V1);}
00409    
00410 double __DUMMY_2;
00411 
00412 }
00413 
00414            
00415        if (__failure) {
00416            // When there is a failure, this code puts the exception
00417            // in __ERROR.
00418            PyObject* err_type = NULL;
00419            PyObject* err_msg = NULL;
00420            PyObject* err_traceback = NULL;
00421            PyErr_Fetch(&err_type, &err_msg, &err_traceback);
00422            if (!err_type) {err_type = Py_None;Py_INCREF(Py_None);}
00423            if (!err_msg) {err_msg = Py_None; Py_INCREF(Py_None);}
00424            if (!err_traceback) {err_traceback = Py_None; 
Py_INCREF(Py_None);}
00425            PyObject* old_err_type = PyList_GET_ITEM(__ERROR, 0);
00426            PyObject* old_err_msg = PyList_GET_ITEM(__ERROR, 1);
00427            PyObject* old_err_traceback = PyList_GET_ITEM(__ERROR, 2);
00428            PyList_SET_ITEM(__ERROR, 0, err_type);
00429            PyList_SET_ITEM(__ERROR, 1, err_msg);
00430            PyList_SET_ITEM(__ERROR, 2, err_traceback);
00431            {Py_XDECREF(old_err_type);}
00432            {Py_XDECREF(old_err_msg);}
00433            {Py_XDECREF(old_err_traceback);}
00434        }
00435        // The failure code is returned to index what code block 
failed.
00436        return __failure;
00437        
00438        }
00439    };
00440    }
00441    
00442 
00443        static int 
__struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707_executor(__struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707
 
*self) {
00444            return self->run();
00445        }
00446 
00447        static void 
__struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707_destructor(PyObject 
*capsule) {
00448            __struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707 
*self = (__struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707 
*)PyCapsule_GetContext(capsule);
00449            delete self;
00450        }
00451        
00452 //////////////////////
00453 ////  Functions
00454 //////////////////////
00455 static PyObject * instantiate(PyObject * self, PyObject *argtuple) {
00456  assert(PyTuple_Check(argtuple));
00457  if (4 != PyTuple_Size(argtuple)){ 
00458     PyErr_Format(PyExc_TypeError, "Wrong number of arguments, 
expected 4, got %i", (int)PyTuple_Size(argtuple));
00459     return NULL;
00460  }
00461  __struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707* struct_ptr = 
new __struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707();
00462  if (struct_ptr->init( PyTuple_GET_ITEM(argtuple, 
0),PyTuple_GET_ITEM(argtuple, 1),PyTuple_GET_ITEM(argtuple, 
2),PyTuple_GET_ITEM(argtuple, 3) ) != 0) {
00463    delete struct_ptr;
00464    return NULL;
00465  }
00466    PyObject* thunk = 
PyCapsule_New((void*)(&__struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707_executor),
 
NULL, __struct_compiled_op_mb7d4d181798f8e2bf5cb5c85493f6707_destructor);
00467    if (thunk != NULL && PyCapsule_SetContext(thunk, struct_ptr) != 0) 
{
00468        PyErr_Clear();
00469        Py_DECREF(thunk);
00470        thunk = NULL;
00471    }
00472 
00473  return thunk; }
00474 
00475 //////////////////////
00476 ////  Module init
00477 //////////////////////
00478 static PyMethodDef MyMethods[] = {
00479 {"instantiate", instantiate, METH_VARARGS, "undocumented"} ,
00480 {NULL, NULL, 0, NULL}
00481 };
00482 static struct PyModuleDef moduledef = {
00483      PyModuleDef_HEAD_INIT,
00484      "mb7d4d181798f8e2bf5cb5c85493f6707",
00485      NULL,
00486      -1,
00487      MyMethods,
00488 };
00489 
00490 PyMODINIT_FUNC PyInit_mb7d4d181798f8e2bf5cb5c85493f6707(void) {
00491   import_array();
00492    PyObject *m = PyModule_Create(&moduledef);
00493    return m;
00494 }
00495 
Problem occurred during compilation with the command line below:
"C:\MinGW\bin\g++.exe" -shared -g -O3 -fno-math-errno -Wno-unused-label 
-Wno-unused-variable -Wno-write-strings 
-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION -m64 -DMS_WIN64 
-I"C:\Users\Bhavana\Anaconda3\lib\site-packages\numpy\core\include" 
-I"C:\Users\Bhavana\Anaconda3\include" 
-I"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof" 
-L"C:\Users\Bhavana\Anaconda3\libs" -L"C:\Users\Bhavana\Anaconda3" -o 
C:\Users\Bhavana\AppData\Local\Theano\compiledir_Windows-10-10.0.14393-SP0-Intel64_Family_6_Model_69_Stepping_1_GenuineIntel-3.5.2-64\tmp74i2w8u9\mb7d4d181798f8e2bf5cb5c85493f6707.pyd
 
C:\Users\Bhavana\AppData\Local\Theano\compiledir_Windows-10-10.0.14393-SP0-Intel64_Family_6_Model_69_Stepping_1_GenuineIntel-3.5.2-64\tmp74i2w8u9\mod.cpp
 
-lpython35
===============================
C:\Users\Bhavana\AppData\Local\Theano\compiledir_Windows-10-10.0.14393-SP0-Intel64_Family_6_Model_69_Stepping_1_GenuineIntel-3.5.2-64\tmp74i2w8u9\mod.cpp:1:0:
 
sorry, unimplemented: 64-bit mode not compiled in
 #include <Python.h>
 ^

Traceback (most recent call last):
  File "C:/Users/Bhavana/PycharmProjects/untitled/1.py", line 7, in <module>
    f = function([a,b],c)
  File 
"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\compile\function.py", 
line 326, in function
    output_keys=output_keys)
  File 
"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\compile\pfunc.py", 
line 486, in pfunc
    output_keys=output_keys)
  File 
"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\compile\function_module.py",
 
line 1795, in orig_function
    defaults)
  File 
"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\compile\function_module.py",
 
line 1661, in create
    input_storage=input_storage_lists, storage_map=storage_map)
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\link.py", 
line 699, in make_thunk
    storage_map=storage_map)[:3]
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\vm.py", 
line 1047, in make_all
    impl=impl))
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\op.py", 
line 935, in make_thunk
    no_recycling)
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\op.py", 
line 839, in make_c_thunk
    output_storage=node_output_storage)
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\cc.py", 
line 1190, in make_thunk
    keep_lock=keep_lock)
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\cc.py", 
line 1131, in __compile__
    keep_lock=keep_lock)
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\cc.py", 
line 1586, in cthunk_factory
    key=key, lnk=self, keep_lock=keep_lock)
  File 
"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\cmodule.py", line 
1159, in module_from_key
    module = lnk.compile_cmodule(location)
  File "C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\cc.py", 
line 1489, in compile_cmodule
    preargs=preargs)
  File 
"C:\Users\Bhavana\Anaconda3\lib\site-packages\theano\gof\cmodule.py", line 
2316, in compile_str
    (status, compile_stderr.replace('\n', '. ')))
Exception: ('The following error happened while compiling the node', 
Elemwise{mul,no_inplace}(a, b), '\n', 'Compilation failed (return 
status=1): 
C:\\Users\\Bhavana\\AppData\\Local\\Theano\\compiledir_Windows-10-10.0.14393-SP0-Intel64_Family_6_Model_69_Stepping_1_GenuineIntel-3.5.2-64\\tmp74i2w8u9\\mod.cpp:1:0:
 
sorry, unimplemented: 64-bit mode not compiled in\r.  #include 
<Python.h>\r.  ^\r. ', '[Elemwise{mul,no_inplace}(a, b)]')

Could anyone suggest on how to resolve this issue.

Thank you.

-- 

--- 
You received this message because you are subscribed to the Google Groups 
"theano-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to theano-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to