小编Sim*_*mon的帖子

我有一些图像,我想要计算Minkowski /盒计数维度,以确定图像中的分形特征.这是2个示例图像:

10.jpg:

24.jpg:

我正在使用以下代码来计算分形维数:

import numpy as np
import scipy

def rgb2gray(rgb):
    r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
    return gray

def fractal_dimension(Z, threshold=0.9):
    # Only for 2d image
    assert(len(Z.shape) == 2)

    # From https://github.com/rougier/numpy-100 (#87)
    def boxcount(Z, k):
        S = np.add.reduceat(
            np.add.reduceat(Z, np.arange(0, Z.shape[0], k), axis=0),
                               np.arange(0, Z.shape[1], k), axis=1)

        # We count non-empty (0) and non-full boxes (k*k)
        return len(np.where((S …

我有一对1D数组(不同长度),如下所示:

data1 = [0,0,0,1,1,1,0,1,0,0,1]
data2 = [0,1,1,0,1,0,0,1]

我想获得python中2系列的最大互相关.在matlab中,xcorr()函数将返回OK

我尝试了以下两种方法:

1. numpy.correlate(data1, data2)
2. signal.fftconvolve(data2, data1[::-1], mode='full')

这两种方法都给了我相同的值,但是我从python获得的值与matlab的值不同.Python给出了整数值> 1,而matlab给出了0到1之间的实际相关值.

我已经尝试首先对2个数组进行标准化(值均值/标准差),但我得到的互相关值是数以千计,似乎不正确.

Matlab还会给出一个交叉相关性最大的滞后值.我假设使用索引很容易做到这一点,但如果我的数组包含数以万计的数值,那么最合适的方法是什么呢？

我想模仿xcorr(matlab的功能,有关如何在python中做到这一点的任何想法？

我想就如何最好地组织我的django模型/数据库表来保存我的webapp中的数据提出一些建议

我正在设计一个站点,用于保存来自赛车模拟游戏的用户遥测数据.因此,将会有一个桌面伴侣应用程序,它将每0.1秒对游戏数据进行一次采样,以获取各种信息(汽车,赛道,速度,汽油,刹车,离合器,转速等).例如,在2分钟的比赛中,每个变量将保持1200个数据点(每秒10个样本*120秒).

这里重要的是这个数据列表可以有多达20个变量,并且可能在将来增长.因此1200*您拥有的变量数量是单个竞赛会话的数据量.如果单个用户提交100个会话,并且有100个用户......数据量会非常快地增加.

然后,应用程序将把竞赛会话的所有数据发送到网站的数据库.数据必须通过CSV文件在游戏和网站之间传输.所以在结构上我只限于CSV可以做什么.然后,该网站将允许您选择比赛时间/圈数并在不同的时间序列图表上绘制此信息(针对每个变量),并且重要的是允许您针对某些人进行策划以查看差异所在

我的问题是你如何构建这样一个数据库来保存这么多信息？

我想到的最简单的结构是为每个赛道创建一个单独的表,然后每个行/条目将成为该赛道上的一个赛道.此表中的字段将是上面的变量.

我遇到的问题是:

1)上面列表中的大多数变量都是时间序列数据而不是单个值(例如变速速度可能如下所示:70,72,74,77,72,71,65,其中值是间隔0.1秒的样本整个圈的过程).如何在表/字段中存储此类信息？

2)上面列表中每个变量的长度对于任何一场比赛都将是相同的长度(如果你的单圈需要1分钟35,那么你所有的变量只能捕获那段时间内的数据),但考虑到我想要的为了能够相互比较不同的圈数,每圈的会话时间将不同.换句话说,然而,我存储这些变量的时间序列数据,它的大小必须是可变的

任何想法将不胜感激

我有大量的交叉相关来计算,我正在寻找最快的方法.我假设向量化问题会有所帮助,而不是用循环来做

我有一个标记为电极x时间点x试验的3D阵列(形状:64x256x913).我想计算每次试验时每对电极的时间点的最大互相关性.

具体来说:对于每次试验,我想取每对电极组合并计算每对的最大互相关值.这将导致单行/向量中的4096(64*64)个最大互相关值.这将针对每个试验进行,将每个行/向量堆叠在彼此之上,从而产生包含最大互相关值的最终2D阵列形状913*4096

这是很多计算,但我想尝试找到最快的方法来做到这一点.我使用列表作为容器来模拟一些原型代码,这可能有助于更好地解释问题.可能存在一些逻辑错误,但无论哪种方式代码都不能在我的计算机上运行,​​因为计算python只是冻结了这么多.就这个:

#allData is a 64x256x913 array

all_experiment_trials = []
for trial in range(allData.shape[2]):
    all_trial_electrodes = []
    for electrode in range(allData.shape[0]):
        for other_electrode in range(allData.shape[0]):
            if electrode == other_electrode:
                pass
            else:
                single_xcorr = max(np.correlate(allData[electrode,:,trial], allData[other_electrode,:,trial], "full"))
                all_trial_electrodes.append(single_xcorr)
    all_experiment_trials.append(all_trial_electrodes)

对于这类事情,显然循环非常慢.是否有使用numpy数组的矢量化解决方案？

我已经检查了像correlate2d()之类的东西,但我认为它们并不适用于我的情况,因为我没有将2个矩阵相乘

我有以 3D numpy 数组（纪元 * 通道 * 时间点）形式出现的 EEG 数据。时间点是一个包含每个采样时间点的 256 个元素数组（总共 1 秒，频率为 256Hz）。epoch 是一个实验性的试验。

我正在尝试将 numpy 数组导入 Python-MNE ( http://martinos.org/mne/stable/mne-python.html ) 理解的表单中，但我遇到了一些麻烦

首先，我不确定是否应该将这些原始数据作为 RawArray 或 EpochsArray 导入。我用这个尝试了后者：

ch_names = list containing my 64 eeg channel names
allData = 3d numpy array as described above

info = mne.create_info(ch_names, 256, ch_types='eeg')

event_id = 1

#I got this from a tutorial but really unsure what it does and I think this may be the problem
events = np.array([200, event_id])  #I got …

我有一个奇怪的问题,当我卸载应用程序时,我的SQL数据库不会自行删除

我不是在任何外部存储目录中创建数据库,并且确认数据库位于其默认位置: /data/data/com.example.app/databases/

卸载应用程序后,我希望擦除该位置的所有数据,但是当我从android studio再次运行应用程序时,新安装仍然可以看到所有旧数据

我已经尝试使用adb手动删除.db数据库目录中的文件,但是当我再次运行应用程序时,仍然可以看到旧数据

我也尝试进入应用程序设置并清除数据和缓存,但这似乎没有帮助

在我的代码中,我对数据库做任何"奇怪"事情的唯一地方是我在按钮点击时将数据库文件复制到新位置:

String pathToExternalStorage = Environment.getExternalStorageDirectory().toString();
File exportDir = new File(pathToExternalStorage, "/SensorData");
File subjectDataDir = new File(exportDir, "/subjects");

File data = Environment.getDataDirectory();
String currentDBPath = "//data//com.example.app//databases//" + DBHelper.DATABASE_NAME;
File currentDB = new File(data, currentDBPath);
File destDB = new File(exportDir, DBHelper.DATABASE_NAME);

FileChannel src = new FileInputStream(currentDB).getChannel();
FileChannel dst = new FileOutputStream(destDB).getChannel();
dst.transferFrom(src, 0, src.size());
src.close();
dst.close();

然后在新创建的文件上运行mediascanner,以便我可以立即获得MTP访问权限

我怀疑这些过程中的任何一个都可能导致这种情况发生吗？

我当前的问题是如何在没有root访问权限的情况下从手机中手动删除数据库？

更大的问题是什么可能导致卸载过程不删除数据库文件？新安装的应用程序版本(卸载后)如何仍然可以看到旧的数据库信息？

我不知道如何开始搞清楚这一点......

编辑:

这变得越来越陌生.这似乎只发生在Windows上.这是我尝试过的过程:

1. 从手机中删除/卸载应用程序
2. 在Windows上从android studio运行应用程序.问题:数据库仍然存在,应用程序看到所有旧数据(即使我卸载了应用程序)
3. 卸载应用
4. 在我的macbook上从android studio运行应用程序.没问题!数据库是新鲜的,没有找到现有数据
5. 再次卸载应用程序
6. 在我的Windows机器上再次测试.现在,数据库返回,应用程序看到旧的​​旧数据库信息(从第2步开始!).此时卸载并没有摆脱它

所以我现在真的很茫然.为什么在Mac上运行会好吗？为什么在Mac上运行并清理数据库后,再次带上旧的Windows数据库呢？这不是所有操作系统都独立吗？

我想知道两种不同的启动可运行方法的性能和 cpu/ram 要求

我有一些代码每 10 毫秒收集一次传感器数据，并将这些值插入到后台线程上的数据库中（使用单线程执行器）。Executor服务创建如下：

executor = Executors.newSingleThreadExecutor();

一种方法是......

public void onSensorChanged(SensorEvent event) {
    //get sensor values

    //insert into database
    executor.execute(new Runnable(){
        //database insert code here
    });
}

我在教程中经常看到这种方法，但因为我每 10 毫秒执行一次，所以感觉资源密集型，因为每次检测到传感器值变化时我都会创建一个新对象。这个新对象是否每 10 毫秒就被覆盖一次？或者随着新对象的创建，它是否会占用越来越多的 RAM？

此后我重构了我的代码，使其看起来更像这样：

executor = Executors.newSingleThreadExecutor();
myRunnable = new MyRunnable();

class MyRunnable implements Runnable {
    public void run() {
        //database insert code here
    }
}

public void onSensorChanged(SensorEvent event) {
    //get sensor values

    //insert into database
    executor.execute(myRunnable);
}

我的想法是，我只实例化一个对象一次，而不是每次传感器发生变化时都实例化一次。我认为这比以前的方法具有更低的 RAM 使用率，这是正确的吗？有没有更有效/更好的方法来完成这项任务？

这是我的问题的后续跟进:Android线程可运行的性能

我在应用程序的同步方法上遇到了一些困难

我正在轮询传感器并在传感器值发生变化时将其存储到数组中

float[] accelerometerMatrix = new float[3];
float[] accelerometerWorldMatrix = new float[3];
float[] gyroscopeMatrix = new float[3];
float[] gravityMatrix = new float[3];
float[] magneticMatrix = new float[3];
float[] rotationMatrix = new float[9];

class InsertHandler implements Runnable {
        public void run() {
            //get values from arrays and insert into db
        }
    }

public void onSensorChanged(SensorEvent event) {
        sensor = event.sensor;

        int i = sensor.getType();
        if (i == MainActivity.TYPE_ACCELEROMETER) {
            accelerometerMatrix = event.values;
        } else if (i == MainActivity.TYPE_GYROSCOPE) { …

假设我有一个这样的数据帧:

   id  num
0   1    1
1   2    2
2   3    1
3   4    2
4   1    1
5   2    2
6   3    1
7   4    2

出于测试目的,可以使用此生成以上内容:

test = pd.DataFrame({'id': np.array([1,2,3,4] * 2,dtype='int32'),
                     'num': np.array([1,2] * 4,dtype='int32')
                    })

现在,我想只保留满足特定条件的行:id不是1 num而不是1.本质上我想删除索引为0和4的行.对于我的实际数据集,它更容易删除我不想要的行而不是指定我想要的行

我试过这个:

test = test[(test['id'] != 1) & (test['num'] != 1)]

但是,这给了我这个:

   id  num
1   2    2
3   4    2
5   2    2
7   4    2

它似乎删除了id1 OR num为1的所有行

我已经看到了其他一些问题,其答案是我上面使用的那个,但在我的案例中它似乎没有成功

我的软件包具有以下结构：

myPackage
 -- __init__.py <-- empty
 -- signal.py
 -- plot.py

signal.py包含：

from plot import plot_signal

def build_filter():
   ...

def other_function():
   plot_signal()

plot.py包含：

from signal import build_filter

def plot_signal():
   ...

def other_function():
   build_filter()

然后，我就有了使用此程序包的脚本，该程序包包含以下内容：

import myPackage as mp

mp.plot.plot_signal()

运行此命令时，出现属性错误： module 'myPackage' has no attribute 'plot'

我不确定为什么将其plot作为包中的模块时将其称为属性，还是将其myPackage称为模块。

然后，我尝试导入我的包并以其他方式调用该函数：

from myPackage import plot, signal

plot.plot_signal()

但是，现在我收到一个导入错误：cannot import name 'build_filter'追溯是指plot.py它试图build_filter()从同级模块导入函数的位置。

我认为这与以下事实有关：两个模块彼此使用函数，并递归地导入另一个模块。

组织此程序包以使同级模块可以相互导入功能的正确方法是什么？